def login_user(addr,account):
server_addr = addr
server_port = "8080"
cloud_user = "******"
cloud_passwd = "admin"
guest_user = account
guest_passwd = account
server_url = '%s%s%s%s%s%s%s%s%s' % ('http://',cloud_user,':',cloud_passwd,'@',server_addr,':',server_port,'/RPC2')
print "Connect to xmlrpc url %s ..." % server_url
try:
server = xmlrpclibex.ServerProxy(server_url)
except:
st_exit(-1,lines(),"failed to create xmlrpc ServerProxy!")
server.system.listMethods()
encrypted_root_session = login(server,cloud_user,cloud_passwd)
if encrypted_root_session is None:
st_exit(-1,lines(),"failed to get encrypted root session!")
# 查询用户帐号是否已经注册
u = user(server,encrypted_root_session)
if u.query(0L, 1000L, guest_user) != True:
# 不存在，则创建普通帐号用户，存在则直接登录
if u.allocate(account,account,account,3,"st_group") != True:
st_exit(-1,lines(),"failed to create new account!")
def testImage(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
# 创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
# 创建一个用户 参数为 user,test,test,3,test_group1 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("user","test","test",ACCOUNTUSER,"test_group1"))
# 登录租户 获取租户session 以备后面使用
user_session = login(server,"user","test")
self.assertNotEqual(user_session,None,"failed to get user session!")
# 以管理员身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,test_root_user,test_root_passwd,test_image),"failed to upload_image_file!")
# 以租户身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,"user","test",test_image),"failed to upload_image_file!")
# 注册集群
root_cluster_manager_method = clustermanager(server,root_session)
#time.sleep(20)
self.assertTrue(root_cluster_manager_method.query(START_INDEX,QUERY_COUNT,SYN_MODE))
# 注册主机
root_host_method = host(server,root_session)
# 等待 20S 等待资源上报
time.sleep(20)
self.assertTrue(root_host_method.query(START_INDEX,QUERY_COUNT,test_cluster,test_host))
# 创建工程
user_project = project(server,user_session)
self.assertTrue(user_project.allocate(test_project_name,"test project description"))
root_project = project(server,root_session)
self.assertTrue(root_project.allocate(test_project_name,"test project description"))
# 设置tcu 8
cpu_id = root_host_method.get_cpu_id(test_cluster,test_host)
self.assertNotEqual(cpu_id,None)
print "cpu id of host %s = %d" % (test_host,cpu_id)
root_tcu_method = tcu(server,root_session)
self.assertTrue(root_tcu_method.set(test_cluster,cpu_id,TCU_NUM8,"test cpu description"))
self.assertTrue(root_tcu_method.query(START_INDEX,QUERY_COUNT,test_cluster,NO_CPU_INFO,cpu_id))
# ------------------管理员自身权限测试------------------
# 测试注册
# 查询管理员上传的image id, 参数为映像文件名，返回值为映像id
i = image(server,root_session)
file_id = i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(file_id,None)
i_id = file_id;
#查询镜像注册时间
self.assertNotEqual(i.query_register_time(file_id),None)
# 修改image 参数为 file_id, "ttylinux2", "", "", "" 应当成功
self.assertTrue(i.set(file_id, "ttylinux2", NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide",NO_IMAGE_DESCRIPTION,"SUSE"))
# 查询image的名字 ，应该为"ttylinux2"
self.assertEqual(i.query_name_by_id(i_id),"ttylinux2")
# 查询image的type ，应该为"machine"
self.assertEqual(i.query_type_by_id(i_id),"machine")
# 修改image 参数为 file_id, "", "kernel", "", "" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, "kernel", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"kernel"
self.assertEqual(i.query_type_by_id(i_id),"kernel")
# 修改image 参数为 file_id, "", "ramdisk", "", "" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, "ramdisk", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"ramdisk"
self.assertEqual(i.query_type_by_id(i_id),"ramdisk")
# 修改image 参数为 file_id, "", "cdrom", "", "" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, "cdrom", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"cdrom"
self.assertEqual(i.query_type_by_id(i_id),"cdrom")
# 修改image 参数为 file_id, "", "datablock", "", "" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, "datablock", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"datablock"
self.assertEqual(i.query_type_by_id(i_id),"datablock")
# 修改image 参数为 file_id, "", "aaaaa", "", "" 应当失败
self.assertFalse(i.set(file_id, NO_IMAGE_NAME, "aaaaa", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该为"x86_64"
self.assertEqual(i.query_arch_by_id(i_id),"x86_64")
# 修改image 参数为 file_id, "", "", "i386", "" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "i386", "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该为"i386"
self.assertEqual(i.query_arch_by_id(i_id),"i386")
########################################################
# 修改image 参数为 file_id, "", "", "i386", "ide","" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "i386", "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该为"i386"
self.assertEqual(i.query_bus_by_id(i_id),"ide")
# 修改image 参数为 file_id, "", "", "i386", "scsi","" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "i386", "scsi",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该为"i386"
self.assertEqual(i.query_bus_by_id(i_id),"scsi")
# 修改image 参数为 file_id, "", "", "i386", "aaa","" 应当失败
self.assertFalse(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "i386", "aaa",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该仍然为最后一次设置的"scsi"
self.assertEqual(i.query_bus_by_id(i_id),"scsi")
########################################################
# 修改image 参数为 file_id, "", "", "aaaa", "" 应当失败
self.assertFalse(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "aaaa", "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的description 应该为 "this is test image"
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, NO_IMAGE_ARCH,"ide", "this is test image", "SUSE"))
self.assertEqual(i.query_description_by_id(i_id),"this is test image")
# 修改image 参数为 file_id, "", "", "", "test" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide", "test", "SUSE"))
# 查询image的description 应该为 "test"
self.assertEqual(i.query_description_by_id(i_id), "test")
# 测试使能
# 查询image 的使能状态 应该为 1
self.assertEqual(i.query_state_by_id(file_id), 1)
# 禁能image 参数为 file_id, 0 应当成功
self.assertTrue(i.enable(file_id,I_DISABLE))
# 查询image 的使能状态 应该为 0
self.assertEqual(i.query_state_by_id(file_id), 0)
# 测试发布
# 查询image 的发布状态 应该为 0(默认）
self.assertEqual(i.query_pub_by_id(file_id), 0)
# 取消image发布 参数为 file_id, 0 应当成功
self.assertTrue(i.publish(file_id,NOT_PUBLIC))
# 查询image 的发布状态 应该为 0
self.assertEqual(i.query_pub_by_id(file_id), 0)
self.assertTrue(i.publish(file_id, IS_PUBLIC))
self.assertEqual(i.query_pub_by_id(file_id), 1)
# 测试查询
i_id = file_id;
# 查询用户创建的image的数量 参数为 0,100, -4,"",0 返回的数量应该是1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_USER_CREAT_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 1)
# 查询用户可见的image的数量 参数为 0,100, -3,"",0 返回的数量应该是1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_USER_CREAT_VISBLE_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 1)
# 查询发布的的image的数量 参数为 0,100, -2,"",0 返回的数量应该是1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_USER_VISBLE_PUBLIC_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 1)
# 查询指定用户的image的数量 参数为 0,100, 0,"admin",0 返回的数量应该是1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_USER,"admin",NO_IMAGE_ID), 1)
# 查询指定id的image的数量 参数为 0,100, 1,"",file_id 返回的数量应该是1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_IMAGE_ID, NO_USER_NAME, i_id), 1)
# 查询系统中所有image的数量 参数为 0,100, 2,"",0 返回的数量应该是2,因为已经自动注册
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_ALL_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 2)
# ------------------普通用户权限------------------
# 测试注册
# 查询租户上传的file_id, 参数 test_image 返回值为文件user_file_id
user_i = image(server,user_session)
user_file_id = user_i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(user_file_id,None)
user_i_id = user_file_id
# 修改image 参数为 user_file_id, "ttylinux2", "", "", "" 应当成功
self.assertTrue(user_i.set(user_file_id, "ttylinux2", NO_IMAGE_TYPE, NO_IMAGE_ARCH,"ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的名字 ，应该为"ttylinux2"
self.assertEqual(user_i.query_name_by_id(user_i_id),"ttylinux2")
# 查询image的type ，应该为"machine"
self.assertEqual(user_i.query_type_by_id(user_i_id),"machine")
# 修改image 参数为 user_file_id, "", "kernel", "", "" 应当成功
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, "kernel", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"kernel"
self.assertEqual(user_i.query_type_by_id(user_i_id), "kernel")
# 修改image 参数为 user_file_id, "", "ramdisk", "", "" 应当成功
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, "ramdisk", NO_IMAGE_ARCH, "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"ramdisk"
self.assertEqual(user_i.query_type_by_id(user_i_id), "ramdisk")
# 修改image 参数为 user_file_id, "", "cdrom", "", "" 应当成功
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, "cdrom", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"cdrom"
self.assertEqual(user_i.query_type_by_id(user_i_id), "cdrom")
# 修改image 参数为 user_file_id, "", "datablock", "", "" 应当成功
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, "datablock", NO_IMAGE_ARCH, "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的type ，应该为"datablock"
self.assertEqual(user_i.query_type_by_id(user_i_id), "datablock")
# 修改image 参数为 user_file_id, "", "aaaa", "", "" 应当失败
self.assertFalse(user_i.set(user_file_id, NO_IMAGE_NAME, "aaaa", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该为"x86_64"
self.assertEqual(user_i.query_arch_by_id(user_i_id), "x86_64")
# 修改image 参数为 user_file_id, "", "", "i386", "" 应当成功
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "i386", "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的arch ，应该为"i386"
self.assertEqual(user_i.query_arch_by_id(user_i_id), "i386")
# 修改image 参数为 user_file_id, "", "", "aaaa", "" 应当失败
self.assertFalse(user_i.set(user_file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "aaaa","ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 查询image的description 应该为 "this is test image"
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, NO_IMAGE_ARCH,"ide", "this is test image", "SUSE"))
self.assertEqual(user_i.query_description_by_id(user_i_id), "this is test image")
# 修改image 参数为 user_file_id, "", "", "", "test" 应当成功
self.assertTrue(user_i.set(user_file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide","test", "SUSE"))
# 查询image的description 应该为 "test"
self.assertEqual(user_i.query_description_by_id(user_i_id), "test")
# 测试使能
# 查询image 的使能状态 应该为 1
self.assertEqual(user_i.query_state_by_id(user_file_id), 1)
# 禁能image 参数为 user_file_id, 0 应当失败
self.assertFalse(user_i.enable(user_file_id,I_DISABLE))
# 查询image 的使能状态 应该为 1
self.assertEqual(user_i.query_state_by_id(user_file_id), 1)
# 测试发布
# 查询image 的发布状态 应该为 0
self.assertEqual(user_i.query_pub_by_id(user_file_id), 0)
# 发布image 参数为 user_file_id, 1 应当失败
self.assertFalse(user_i.publish(file_id,NOT_PUBLIC))
# 查询image 的发布状态 应该为 0
self.assertEqual(user_i.query_pub_by_id(user_file_id), 0)
# 测试查询
user_i_id = user_file_id
# 查询用户创建的image的数量 参数为 0,100, -4,"",0 返回的数量应该是1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_USER_CREAT_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 1)
# 查询用户可见的image的数量 参数为 0,100, -3,"",0 返回的数量应该是2
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_USER_CREAT_VISBLE_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 2)
# 查询发布的的image的数量 参数为 0,100, -2,"",0 返回的数量应该是1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_USER_VISBLE_PUBLIC_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 1)
# 查询指定用户的image的数量 参数为 0,100, 0,"user",0 返回的数量应该是1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_USER, NO_USER_NAME, NO_IMAGE_ID), 1)
# 查询指定id的image的数量 参数为 0,100, 1,"",user_file_id 返回的数量应该是1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_IMAGE_ID, NO_USER_NAME, user_file_id), 1)
# 查询系统中所有image的数量 参数为 0,100, 2,"",0 应该返回-1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_ALL_IMAGE, NO_USER_NAME, NO_IMAGE_ID), None)
# 测试修改别人的映像
# 使用用户session 修改image 参数为 file_id, "ttylinux2", "", "", "" 应当失败
self.assertFalse(user_i.set(file_id, "ttylinux2", NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 测试使能别人的映像
# 使用用户session 禁能image 参数为 file_id, 0 应当失败
self.assertFalse(user_i.enable(file_id, I_DISABLE))
# 测试发布别人的映像
# 使用用户session 发布image 参数为 file_id, 1 应当失败
self.assertFalse(user_i.publish(file_id, IS_PUBLIC))
# 测试查询别人的映像
#下面几个测试使用用户serssion
# 查询指定用户的image的数量 参数为 0,100, 0,"admin",0 应当返回-1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_USER,"admin",NO_IMAGE_ID), None)
# 查询指定id的image的数量 参数为 0,100, 1,"",file_id
#管理员不进行发布查询数量为0，返回的数量应该是-1
self.assertTrue(i.publish(file_id,NOT_PUBLIC))
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_IMAGE_ID, NO_USER_NAME, file_id), None)
#管理员发布后查询数量为1
self.assertTrue(i.publish(file_id,IS_PUBLIC))
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_IMAGE_ID, NO_USER_NAME, file_id), 1)
# 查询系统中所有image的数量 参数为 0,100, 2,"",0 应该返回-1
self.assertEqual(user_i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_ALL_IMAGE, NO_USER_NAME, NO_IMAGE_ID), None)
# ------------------管理员其他权限测试------------------
# 测试注销别人的映像
# 测试修改别人的映像
# 使用管理员session 修改image 参数为 user_file_id, "ttylinux2", "", "", "" 应当成功
self.assertTrue(i.set(user_file_id, "ttylinux2", NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide", NO_IMAGE_DESCRIPTION, "SUSE"))
# 测试使能别人的映像
# 使用管理员session 禁能image 参数为 user_file_id, 0 应当成功
self.assertTrue(i.enable(user_file_id, I_DISABLE))
# 使用管理员session查询image 的使能状态 应该为0
self.assertEqual(i.query_state_by_id(user_file_id), 0)
# 使用管理员session 使能image 参数为 user_file_id, 1 应当成功
self.assertTrue(i.enable(user_file_id, I_ENABLE))
# 使用管理员session查询image 的使能状态 应该为1
self.assertEqual(i.query_state_by_id(user_file_id), 1)
# 测试发布别人的映像
# 使用管理员session 发布image 参数为 user_file_id, 1 应当成功
self.assertTrue(i.publish(user_file_id, IS_PUBLIC))
# 使用管理员session查询image 的发布状态 应该为1
self.assertEqual(i.query_pub_by_id(user_file_id), IS_PUBLIC)
# 使用管理员session 取消发布image 参数为 user_file_id, 0 应当成功
self.assertTrue(i.publish(user_file_id, NOT_PUBLIC))
# 使用管理员session查询image 的发布状态 应该为0
self.assertEqual(i.query_pub_by_id(user_file_id), NOT_PUBLIC)
# 测试查询别人的映像
#下面几个测试使用管理员serssion
# 查询指定用户的image的数量 参数为 0,100, 0,"user",0 应当返回1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_USER,"user", NO_IMAGE_ID), 1)
# 查询指定id的image的数量 参数为 0,100, 1,"",user_file_id 返回的数量应该是1
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_BY_IMAGE_ID, NO_USER_NAME,user_file_id), 1)
# 查询系统中所有image的数量 参数为 0,100, 2,"",0 应该返回2
self.assertEqual(i.get_query_count(START_INDEX,QUERY_COUNT, QUERY_ALL_IMAGE, NO_USER_NAME, NO_IMAGE_ID), 2)
# ------------------image 被使用后的测试------------------
# 该测试段都使用管理员身份来进行测试,创建虚拟机除外，创建虚拟机的接口需要使用租户的身份来创建
# 创建虚拟下面是虚拟机创建的参数(使用租户身份进行创建) 应该成功
cfg = {}
cfg["vm_name"] = test_vm_name
cfg["project_name"] = test_project_name
cfg["vm_num"] = 1
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 4
cfg["base_info"]["memory"] = long(256 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":file_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
user_v = vmcfg(server,user_session)
self.assertFalse(user_v.allocate(cfg))
self.assertTrue(i.enable(file_id, I_ENABLE))
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, "machine", NO_IMAGE_ARCH,"ide", NO_IMAGE_DESCRIPTION, "SUSE"))
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "x86_64", "ide", NO_IMAGE_DESCRIPTION, "SUSE"))
self.assertTrue(user_v.allocate(cfg))
self.assertNotEqual(user_v.get_vm_id(test_vm_name),None)
# 修改虚拟机的各个字段
# 修改image 参数为 file_id, "ttylinux2", "", "", "" 应当成功
self.assertTrue(i.set(file_id, "ttylinux2", NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 修改image 参数为 file_id, "", "kernel", "", "" 应当失败
self.assertFalse(i.set(file_id, NO_IMAGE_NAME, "kernel", NO_IMAGE_ARCH, "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 修改image 参数为 file_id, "", "", "i386", "" 应当失败
self.assertFalse(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, "i386", "ide",NO_IMAGE_DESCRIPTION, "SUSE"))
# 修改image 参数为 file_id, "", "", "", "test" 应当成功
self.assertTrue(i.set(file_id, NO_IMAGE_NAME, NO_IMAGE_TYPE, NO_IMAGE_ARCH, "ide","test", "SUSE"))
#611003132165 web界面上显示的image引用计数需包含被模板引用的次数
#查询镜像被私有模板引用次数 此时未创建过模板，应该为0
self.assertEqual(i.query_ref_count_by_private_vt(file_id),0)
#查询镜像被公有模板引用次数 此时未创建过模板，应该为0
self.assertEqual(i.query_ref_count_by_public_vt(file_id),0)
# 测试使用快速创建接口来进行创建参数如下： 应该成功
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(0)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 2
cfg["base_info"]["memory"] = long(128 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":i_id,"position":1,"size":0L,"bus":"scsi","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
vt = vmtemplate(server,root_session)
self.assertTrue(vt.allocate(cfg))
#查询镜像被私有模板引用次数 ，应该为1
self.assertEqual(i.query_ref_count_by_private_vt(file_id),1)
#查询镜像被公有模板引用次数 ，应该为0
self.assertEqual(i.query_ref_count_by_public_vt(file_id),0)
#模板发布
self.assertTrue(vt.publish_vmt(test_vt_name))
#查询镜像被私有模板引用次数 ，应该为0
self.assertEqual(i.query_ref_count_by_private_vt(file_id),0)
#查询镜像被公有模板引用次数 ，应该为1
self.assertEqual(i.query_ref_count_by_public_vt(file_id),1)
#取消模板发布
self.assertTrue(vt.unpublish_vmt(test_vt_name))
#查询镜像被私有模板引用次数 ，应该为1
self.assertEqual(i.query_ref_count_by_private_vt(file_id),1)
#查询镜像被公有模板引用次数 ，应该为0
self.assertEqual(i.query_ref_count_by_public_vt(file_id),0)
#删除模板
self.assertTrue(vt.del_vmt(test_vt_name))
#查询镜像被私有模板引用次数 ，应该为0
self.assertEqual(i.query_ref_count_by_private_vt(file_id),0)
#查询镜像被公有模板引用次数 ，应该为0
self.assertEqual(i.query_ref_count_by_public_vt(file_id),0)
# 使能测试
# 禁能image 参数为 file_id, 0 ,vms_running =1 ,应当失败
self.assertFalse(i.enable(file_id, I_DISABLE))
# 发布测试
# 取消发布image 参数为 file_id, 0 应当失败
self.assertFalse(i.publish(file_id, NOT_PUBLIC))
# 注销测试
# 查询image 的 running_vms 参数为 0,100, 1,"",file_id 应该为1
self.assertEqual(i.query_running_vms_by_id(file_id), 1)
#running_vms！=0时删除管理员上传的镜像，应该失败
self.assertFalse(i.delete(file_id))
# 删除虚拟机(使用租户的身份进行虚拟机删除)
user_v_id = user_v.get_vm_id(test_vm_name)
self.assertNotEqual(user_v_id,None)
self.assertTrue(user_v.action(user_v_id,"delete"))
# 查询image 的 running_vms 参数为 0,100, 1,"",file_id 应该为0
self.assertEqual(i.query_running_vms_by_id(file_id), 0)
#删除管理员上传的镜像
self.assertTrue(i.delete(file_id))
#删除租户上传的镜像
self.assertTrue(i.delete(user_file_id))
#删除租户上传的镜像后根据名字查询，应该为空
user_file_id = user_i.get_id_by_filename(os.path.basename(test_image))
self.assertEqual(user_file_id, None)
svr_info = user_i.query_image_ftp_svr_info()
self.assertNotEqual(svr_info,None)
print "success to test test_007_image.py"
def suite():
suite = unittest.TestSuite()
suite.addTest(ImageTestCase())
return suite
ci_exit(-1,"failed to create xmlrpc ServerProxy!")
#列出当前支持的所有xmlrpc接口
server.system.listMethods()
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
encrypted_root_session = login(server,test_root_user,test_root_passwd)
if encrypted_root_session is None:
ci_exit(-1,"failed to get encrypted root session!")
# 创建一个管理组及管理员帐号
ug = usergroup(server,encrypted_root_session)
if ug.allocate(test_admin_usergroup,1) is not True:
ci_exit(-1)
u = user(server,encrypted_root_session)
if u.allocate(test_admin_user,test_admin_passwd,test_admin_passwd,1,test_admin_usergroup) != True:
ci_exit(-1)
# 创建一个用户组及租户帐号
ug3 = usergroup(server,encrypted_root_session)
if ug3.allocate(test_tenant_usergroup,3) is not True:
ci_exit_ex(-1,line())
u3 = user(server,encrypted_root_session)
if u3.allocate(test_tenant_user,test_tenant_passwd,test_tenant_passwd,3,test_tenant_usergroup) != True:
ci_exit_ex(-1,line())
# 登录租户 获取租户session 以备后面使用
user_session = login(server,test_tenant_user,test_tenant_passwd)
if user_session is None:
ci_exit_ex(-1,"failed to get user session!")
def testHost(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
# 创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
# 创建一个用户 参数为 user,test,test,3,test_group1 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("user","test","test",ACCOUNTUSER,"test_group1"))
# 登录租户 获取租户session 以备后面使用
user_session = login(server,"user","test")
self.assertNotEqual(user_session, None, "failed to get user session!")
# 以管理员身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,test_root_user,test_root_passwd,test_image),"failed to upload_image_file!")
# 以租户身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,"user","test",test_image),"failed to upload_image_file!")
# 注册集群
root_cluster_manager_method = clustermanager(server,root_session)
self.assertTrue(root_cluster_manager_method.query(START_INDEX,QUERY_COUNT,SYN_MODE))
# 等待 20S 等待资源上报
#time.sleep(20)
# 创建工程
user_project = project(server,user_session)
self.assertTrue(user_project.allocate(test_project_name,"test project description"))
root_project = project(server,root_session)
self.assertTrue(root_project.allocate(test_project_name,"test project description"))
# 设置tcu 8
root_host_method = host(server,root_session)
cpu_id = root_host_method.get_cpu_id(test_cluster,test_host)
self.assertNotEqual(cpu_id, None)
print "cpu id of host %s = %d" % (test_host,cpu_id)
root_tcu_method = tcu(server,root_session)
self.assertTrue(root_tcu_method.set(test_cluster,cpu_id,TCU_NUM8,"test cpu description"))
self.assertTrue(root_tcu_method.query(START_INDEX,QUERY_COUNT,test_cluster,"",cpu_id))
# 注册image
# 根据文件名获取刚刚上传的映像文件在tecs中的id
i = image(server,root_session)
image_id = i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(image_id, None,"failed to get image id!")
# ------------------管理员自身权限测试------------------
# 测试注册
# 注册主机 参数为 test_cluster,test_host,False,"test" 应该成功
h = host(server,root_session)
# 等待20S
#time.sleep(20)
# 查询主机的运行状态 参数为 0,100,test_cluster,test_host 应该为 3
#刘毅cc整改时更改ON_LINE为2
self.assertEqual(h.query_run_state(test_cluster,test_host), ON_LINE)
# 测试使能
# 使能主机 参数为 test_cluster,test_host 应该成功
self.assertTrue(h.enable(test_cluster,test_host))
# 查询主机的使能状态 参数为 0,100,test_cluster,test_host 应该为 0
self.assertEqual(h.query_enable_state(test_cluster,test_host), HOST_DISABLE)
# 测试禁能
# 禁能主机 参数为 test_cluster,test_host,1 应该成功
self.assertTrue(h.disable(test_cluster,test_host,HOST_ENABLE))
# 查询主机的使能状态 参数为 0,100,test_cluster,test_host 应该为 1
self.assertEqual(h.query_enable_state(test_cluster,test_host), HOST_ENABLE)
#添加EC611002999057 修改host属性改用set接口
self.assertTrue(h.set(test_cluster,test_host,"test"))
#重复注册 应该成功
self.assertTrue(h.set(test_cluster,test_host,"test"))
# 注册主机 参数为 test_cluster,"","test" 应该失败（主机名为空）
self.assertFalse(h.set(test_cluster,"","test"))
# 注册主机 参数为 test_cluster,"no_exist","test" 应该失败（主机不存在）
self.assertFalse(h.set(test_cluster,"no_exist","test"))
# 遗忘主机 参数为 test_cluster,test_host 应该失败
self.assertTrue(h.forget(test_cluster,test_host))
# 下面两条测试暂时不实现，因为要考虑到第3方HC的加入，现阶段只测试3合一的情况
# 测试重启
# 测试关机
# ------------------租户自身权限测试------------------
user_h = host(server,user_session)
# 测试使能
# 使能主机 参数为 test_cluster,test_host 应该失败
self.assertFalse(user_h.enable(test_cluster,test_host))
# 测试禁能
# 禁能主机 参数为 test_cluster,test_host,1 应该失败
self.assertFalse(user_h.disable(test_cluster,test_host,HOST_ENABLE))
# 测试遗忘
# 遗忘主机 参数为 test_cluster,test_host 应该失败
self.assertFalse(user_h.forget(test_cluster,test_host))
# ------------------管理员其他权限测试------------------
# 无
# ------------------和虚拟机相关测试------------------
time.sleep(20)
# 以租户身份部署一个虚拟机，具体参数参考image 模块
cfg_base = {}
cfg_base["vcpu"] = 1
cfg_base["tcu"] = 1
cfg_base["memory"] = long(128 * 1024 * 1024)
cfg_base["cluster"] = ""
cfg_base["host"] = ""
cfg_base["vm_wdtime"] = 0
cfg_base["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg_base["kernel"] = {"id":-1L,"size":0L}
cfg_base["ramdisk"] = {"id":-1L,"size":0L,"bus":"scsi"}
cfg_base["virt_type"] = "hvm"
cfg_base["root_device"] = ""
cfg_base["kernel_command"] = ""
cfg_base["rawdata"] = ""
cfg_base["context"] = {}
cfg_base["qualifications"] = []
cfg = {}
cfg["base_info"] = cfg_base
cfg["vm_name"] = test_vm_name
cfg["project_name"] = test_project_name
cfg["vm_num"] = 1
v = vmcfg(server,root_session)
self.assertTrue(v.allocate(cfg))
#部署虚拟机之前，打印集群资源，以便部署失败时查看信息
cm = clustermanager(server,root_session)
self.assertTrue(cm.query(START_INDEX,QUERY_COUNT,SYN_MODE))
#部署虚拟机
self.assertTrue(v.action(v.get_vm_id(test_vm_name),"deploy"))
# 等待2S，等待虚拟机部署完毕
time.sleep(2)
# 禁能主机 参数为 test_cluster,test_host 应该失败
self.assertFalse(h.disable(test_cluster,test_host,HOST_DISABLE))
# 查询主机运行的虚拟机数量 0,100,test_cluster,test_host 应该为 1
self.assertEqual(h.query_running_vms(test_cluster,test_host), 1)
#测试结束
print "success to test test_009_host.py"
def suite():
suite = unittest.TestSuite()
suite.addTest(HostTestCase())
return suite
def testProject(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
#创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
# 创建一个用户 参数为 user,test,test,3,test_group1 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("user","test","test",ACCOUNTUSER,"test_group1"))
# 登录租户 获取租户session 以备后面使用
user_session = login(server,"user","test")
self.assertNotEqual(user_session,None,"failed to get user session!")
# 以管理员身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,test_root_user,test_root_passwd,test_image),"failed to upload_image_file!")
# 以租户身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,"user","test",test_image),"failed to upload_image_file!")
# 注册集群
root_cluster_manager_method = clustermanager(server,root_session)
self.assertTrue(root_cluster_manager_method.query(START_INDEX,QUERY_COUNT,SYN_MODE))
# 注册主机
root_host_method = host(server,root_session)
# 等待 20S 等待资源上报
#time.sleep(20)
self.assertTrue(root_host_method.query(START_INDEX,QUERY_COUNT,test_cluster,test_host))
# 设置tcu 8
cpu_id = root_host_method.get_cpu_id(test_cluster,test_host)
self.assertNotEqual(cpu_id,None)
print "cpu id of host %s = %d" % (test_host,cpu_id)
root_tcu_method = tcu(server,root_session)
self.assertTrue(root_tcu_method.set(test_cluster,cpu_id,TCU_NUM8,"test cpu description"))
self.assertTrue(root_tcu_method.query(START_INDEX,QUERY_COUNT,test_cluster,NO_CPU_INFO,cpu_id))
# 注册image
# 根据文件名获取刚刚上传的映像文件在tecs中的id
i = image(server,root_session)
image_id = i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(image_id,None,"failed to get image id!")
# ------------------管理员自身权限测试------------------
# 使用 root_session 来进行操作
# 创建工程
# 参数为 test_project_name, "testaaa" 应该成功
p = project(server,root_session)
self.assertTrue(p.allocate(test_project_name,"testaaa"))
# 创建重名的工程
# 参数为 test_project_name, "testbbb" 应该失败
self.assertFalse(p.allocate(test_project_name,"testbbb"))
# 查看工程的描述
# 参数为 0,100,0,test_project_name,"" 应该为 "testaaa"
self.assertEqual(p.query_des_by_name(test_project_name), "testaaa")
# 修改工程描述
# 参数为 test_project_name, "testbbb" 应该成功
self.assertTrue(p.set(test_project_name,"testbbb"))
# 查看修改的描述
# 参数为 0,100,0,test_project_name,"" 应该为 "testbbb"
self.assertEqual(p.query_des_by_name(test_project_name), "testbbb")
# 工程查询测试
# 查询创建的工程数量
# 参数为 0,100,-5,"","" 应该返回1
self.assertEqual(p.query_count(START_INDEX,QUERY_COUNT,USER_CREAT_PROJECT,NO_PROJECT_NAME,NO_USER_NAME), 1)
# 查询所有用户创建的工程数量
# 参数为 0,100,-3,"","" 应该返回1
self.assertEqual(p.query_count(START_INDEX,QUERY_COUNT,ALL_USER_PROJECT,NO_PROJECT_NAME,NO_USER_NAME), 1)
# 查询工程中拥有虚拟机数量
# 参数为 0,30,test_project_name,"" 应该返回0
self.assertEqual(p.query_vm_cout_by_project(VM_START_INDEX,VM_QUERY_COUNT,test_project_name,NO_USER_NAME), None)
# 工程删除测试
# 参数为 test_project_name,"" 应该返回成功
self.assertTrue(p.delete(test_project_name,NO_USER_NAME))
# ------------------租户自身权限测试------------------
# 使用 user_session 来进行操作
# 创建工程
# 参数为 test_project_name, "testaaa" 应该成功
user_p = project(server,user_session)
self.assertTrue(user_p.allocate(test_project_name,"testaaa"))
# 创建重名的工程
# 参数为 test_project_name, "testbbb" 应该失败
self.assertFalse(user_p.allocate(test_project_name,"testbbb"))
# 查看工程的描述
# 参数为 0,100,0,test_project_name,"" 应该为 "testaaa"
self.assertEqual(user_p.query_des_by_name(test_project_name), "testaaa")
# 修改工程描述
# 参数为 test_project_name, "testbbb" 应该成功
self.assertTrue(user_p.set(test_project_name,"testbbb" ))
# 查看修改的描述
# 参数为 0,100,0,test_project_name,"" 应该为 "testbbb"
self.assertEqual(user_p.query_des_by_name(test_project_name), "testbbb")
# 工程查询测试
# 查询创建的工程数量
# 参数为 0,100,-5,"","" 应该返回1
self.assertEqual(user_p.query_count(START_INDEX,QUERY_COUNT,USER_CREAT_PROJECT,NO_PROJECT_NAME,NO_USER_NAME), 1)
# 查询所有用户创建的工程数量
# 参数为 0,100,-3,"","" 应该返回 -1
self.assertEqual(user_p.query_count(START_INDEX,QUERY_COUNT,ALL_USER_PROJECT,NO_PROJECT_NAME,NO_USER_NAME), None)
# 查询工程中拥有虚拟机数量
# 参数为 0,30,test_project_name,"" 应该返回0
self.assertEqual(user_p.query_vm_cout_by_project(VM_START_INDEX,VM_QUERY_COUNT,test_project_name,NO_USER_NAME), None)
# 工程删除测试
# 参数为 test_project_name,"" 应该返回成功
self.assertTrue(user_p.delete(test_project_name,NO_USER_NAME))
# 参数为 test_project_name,"admin" 应该返回失败
self.assertFalse(user_p.delete(test_project_name,"admin"))
# ------------------管理员其他权限测试------------------
# 构建该测试段使用的环境
# 使用user_session 创建一个工程
# 参数为 test_project_name, "testaaa" 应该成功
user_p = project(server,user_session)
self.assertTrue(user_p.allocate(test_project_name,"testaaa"))
# 查询租户创建的工程
# 查询用户的工程数量
# 参数为 0,100,-3,"","" 所有用户的 应该返回 1
self.assertEqual(p.query_count(START_INDEX,QUERY_COUNT,ALL_USER_PROJECT,NO_PROJECT_NAME,NO_USER_NAME), 1)
# 参数为 0,100,0, “” ,"user" ，指定用户的 应返回 None
self.assertEqual(p.query_count(START_INDEX,QUERY_COUNT,APPOINTED_USER_PROJECT,NO_PROJECT_NAME,"user"), 1)
# 参数为 0,100,-5,"","" 当前用户的 应该返回 0
self.assertEqual(p.query_count(START_INDEX,QUERY_COUNT,USER_CREAT_PROJECT,test_project_name, NO_USER_NAME), 0)
# 参数为 0,100,-5,"","" 当前用户空间指定project 应该返回 None
self.assertEqual(p.query_count(START_INDEX,QUERY_COUNT,QUERY_BY_PROJECT_NAME,test_project_name, NO_USER_NAME), None)
# 删除租户创建的工程
# 参数为 test_project_name,"user" 应该返回成功
self.assertTrue(p.delete(test_project_name,"user"))
# ------------------和虚拟机相关测试------------------
# 管理员身份进行测试
# 创建一个虚拟机
cfg = {}
cfg_base = {}
cfg_base["vcpu"] = 2
cfg_base["tcu"] = 1
cfg_base["memory"] = long(128 * 1024 * 1024)
cfg_base["cluster"] = ""
cfg_base["host"] = ""
cfg_base["vm_wdtime"] = 0
cfg_base["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg_base["kernel"] = {"id":-1L,"size":0L}
cfg_base["ramdisk"] = {"id":-1L,"size":0L,"bus":"scsi"}
cfg_base["virt_type"] = "hvm"
cfg_base["root_device"] = ""
cfg_base["kernel_command"] = ""
cfg_base["rawdata"] = ""
cfg_base["context"] = {}
cfg["base_info"] = cfg_base
cfg["vm_name"] = test_vm_name
cfg["project_name"] = test_project_name
cfg["vm_num"] = 1
self.assertTrue( p.allocate(test_project_name,"testaaa"))
v = vmcfg(server,root_session)
self.assertTrue(v.allocate(cfg) )
# 删除拥有虚拟机的工程
# 参数为 test_project_name,"" 应该返回失败
self.assertFalse(p.delete(test_project_name,""))
# 修改工程名称
# 参数为 test_project_name, "testbbb" 应该成功
self.assertTrue(p.set(test_project_name, "testbbb"))
# 查询工程下面拥有的虚拟机信息
# 调用工程中查询虚拟机的接口，查询虚拟机名
# 参数为 0,30,test_project_name,"" 应该返回 None
# 暂时先注掉 chenww 2012/12/12
self.assertEqual(p.query_vm_name_by_project(VM_START_INDEX,VM_QUERY_COUNT,test_project_name,NO_USER_NAME), None)
# 部署虚拟机 应当成功
#查询虚拟机ID
vm_id = v.get_vm_id(test_vm_name)
self.assertTrue(v.action(vm_id,"deploy"))
# 查询状态 应该是2（可采用5S查询一次，一共查询10次，如果10次都查询失败，则退出）
count = 0
vm_state=U_STATE_UNKNOWN
while (v.get_vm_state(vm_id) != U_STATE_RUNNING and v.get_vm_state(vm_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count<17)
# 再创建一个虚拟机
cfg = {}
cfg_base = {}
cfg_base["vcpu"] = 2
cfg_base["tcu"] = 1
cfg_base["memory"] = long(128 * 1024 * 1024)
cfg_base["cluster"] = ""
cfg_base["host"] = ""
cfg_base["vm_wdtime"] = 0
cfg_base["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg_base["kernel"] = {"id":-1L,"size":0L}
cfg_base["ramdisk"] = {"id":-1L,"size":0L,"bus":"scsi"}
cfg_base["virt_type"] = "hvm"
cfg_base["hypervisor"] = "xen"
cfg_base["root_device"] = ""
cfg_base["kernel_command"] = ""
cfg_base["rawdata"] = ""
cfg_base["context"] = {}
cfg["base_info"] = cfg_base
cfg["vm_name"] = test_vm_name1
cfg["project_name"] = test_project_name
cfg["vm_num"] = 1
vm = vmcfg(server,root_session)
self.assertTrue(vm.allocate(cfg) )
# 部署虚拟机 应当成功
#查询虚拟机ID
vm_id1 = vm.get_vm_id(test_vm_name1)
self.assertTrue(vm.action(vm_id1,"deploy"))
# 查询状态 应该是2（可采用5S查询一次，一共查询10次，如果10次都查询失败，则退出）
count = 0
vm_state=U_STATE_UNKNOWN
while (vm.get_vm_state(vm_id1) != U_STATE_RUNNING and vm.get_vm_state(vm_id1)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count<17)
# 查询工程下的静态数据
# 参数为 0,100,-3,"","" 所有用户的 应该返回 1
self.assertEqual(p.statistics_static_data(START_INDEX,QUERY_COUNT,ALL_USER_PROJECT,NO_PROJECT_NAME,NO_USER_NAME), True)
# 参数为 0,100,-4, “” ,"user" ，指定用户的 应返回 None
self.assertEqual(p.statistics_static_data(START_INDEX,QUERY_COUNT,APPOINTED_USER_PROJECT,NO_PROJECT_NAME,"admin"), True)
# 参数为 0,100,-5,"","" 当前用户的 应该返回 0
self.assertEqual(p.statistics_static_data(START_INDEX,QUERY_COUNT,USER_CREAT_PROJECT,test_project_name, NO_USER_NAME), True)
# 参数为 0,100,0,"","" 当前用户空间指定project 应该返回 None
self.assertEqual(p.statistics_static_data(START_INDEX,QUERY_COUNT,QUERY_BY_PROJECT_NAME,test_project_name, NO_USER_NAME), True)
# 删除虚拟机
v_id = v.get_vm_id(test_vm_name)
v.action(v_id,"cancel")
while (v.get_vm_state(v_id)!=U_STATE_CONFIGURATION and v.get_vm_state(v_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count<17)
self.assertTrue(v.action(v_id,"delete") )
vm.action(vm_id1,"cancel")
while (vm.get_vm_state(vm_id1)!=U_STATE_CONFIGURATION and vm.get_vm_state(vm_id1)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count<17)
self.assertTrue(vm.action(vm_id1,"delete") )
# 删除工程
# 参数为 test_project_name,"" 应该返回成功
self.assertTrue(p.delete(test_project_name,NO_USER_NAME))
#测试结束
print "success to test test_008_project.py"
def suite():
suite = unittest.TestSuite()
suite.addTest(ProjectTestCase())
return suite
def testCM(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
#创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
# 创建一个用户 参数为 user,test,test,3,test_group1 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("user","test","test",ACCOUNTUSER,"test_group1"))
# 登录租户 获取租户session 以备后面使用
user_session = login(server,"user","test")
self.assertNotEqual(user_session, None,"failed to get user session!")
#等待20s
#time.sleep(20)
cm = clustermanager(server,root_session)
#查询第一个存在的集群 应该能查询到
fisrt_clustername = cm.get_fisrt_clustername()
self.assertNotEqual(fisrt_clustername,None,"get_fisrt_clustername fail")
#设置查询到的集群 应该成功
self.assertTrue(cm.set(fisrt_clustername,"test set"))
#再次修改集群描述信息 应该成功
self.assertTrue(cm.set(fisrt_clustername,"test modify info"))
#查看集群是使能状态 应该是1
# 611003123663 TC数据库整改，ApiCluster中的registe_state、run_state删除掉，增加is_online、enabled字段
self.assertEqual(cm.get_enabled(fisrt_clustername,SYN_MODE), CM_ENABLE)
#同步方式查看集群的在线状态 应该是在线的
# 611003123663 TC数据库整改，ApiCluster中的registe_state、run_state删除掉，增加is_online、enabled字段
self.assertEqual(cm.get_is_online(fisrt_clustername,SYN_MODE), IS_ONLINE)
#设置一个不存在的集群 参数为"test_cluster" 应该失败
#if cm.set("test_cluster","test set not exist cc") != True:
# ci_exit_ex(-1)
#查看不存在集群的在线状态 应该是离线的
# 611003123663 TC数据库整改，ApiCluster中的registe_state、run_state删除掉，增加is_online、enabled字段
self.assertEqual(cm.get_is_online("test_cluster",SYN_MODE),None)
#注销不存在的集群 应该是成功的
#if cm.forget("test_cluster") != True:
# ci_exit_ex(-1)
#遗忘存在的集群 应该是成功的
self.assertTrue(cm.forget(fisrt_clustername))
#等待重新获取集群
count = 0
while (cm.get_fisrt_clustername() != fisrt_clustername):
time.sleep(1)
count = count + 1
self.assertTrue(count < 19)
print "get_fisrt_clustername count= %d "% count
#disable 一个注册的集群 应该是成功的
self.assertTrue(cm.disable(fisrt_clustername))
#查看集群的使能状态应 该为0
# 611003123663 TC数据库整改，ApiCluster中的registe_state、run_state删除掉，增加is_online、enabled字段
self.assertEqual(cm.get_enabled(fisrt_clustername,SYN_MODE), CM_DISABLE)
#enable 注册的集群 应该成功
self.assertTrue(cm.enable(fisrt_clustername))
#查看当前的集群使能状态 应该为1
# 611003123663 TC数据库整改，ApiCluster中的registe_state、run_state删除掉，增加is_online、enabled字段
self.assertEqual(cm.get_enabled(fisrt_clustername,SYN_MODE), CM_ENABLE)
#等20S
#time.sleep(20)
#查看当前的集群运行状态 应该为在线
# 611003123663 TC数据库整改，ApiCluster中的registe_state、run_state删除掉，增加is_online、enabled字段
self.assertEqual(cm.get_is_online(fisrt_clustername,SYN_MODE), IS_ONLINE)
#查看当前最大core数目
self.assertNotEqual(cm.get_core_num(),None)
#查看当前最大tcu数目
self.assertNotEqual(cm.get_tcu_num(),None)
#查看指定网络平面
#self.assertNotEqual(cm.get_netplane(fisrt_clustername),None)
#---------------普通租户测试开始------------
print "************begin user test****************"
cm3 = clustermanager(server,user_session)
#查询集群信息 应该是失败的
self.assertFalse(cm3.query(START_INDEX,QUERY_COUNT,SYN_MODE))
#设置集群信息 应该是失败的
self.assertFalse(cm3.set(fisrt_clustername,"test setcc"))
#遗忘集群 应该是失败的
self.assertFalse(cm3.forget(fisrt_clustername))
#修改集群信息 应该是失败的
self.assertFalse(cm3.set(fisrt_clustername,"test modify info"))
#查看当前最大core数目 应当成功
self.assertNotEqual(cm3.get_core_num(),None)
#查看当前最大tcu数目 应当成功
self.assertNotEqual(cm3.get_tcu_num(),None)
#查看指定网络平面 应当成功
#self.assertNotEqual(cm3.get_netplane(fisrt_clustername),None)
#测试结束
print "success to test test_004_cluster_manager.py"
def suite():
suite = unittest.TestSuite()
suite.addTest(CMTestCase())
return suite
def testSmoking(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
# 注册cc到tc
print "=============================================="
cm = clustermanager(server,root_session)
#TODO 需要增加循环等待
count=0
while (cm.get_cluster_max_count() == 0):
time.sleep(1)
count = count + 1
self.assertTrue(count < 19)
print "get_cluster_max_count count= %d "% count
#查询集群列表
self.assertTrue(cm.query(START_INDEX,QUERY_COUNT,ASYN_MODE))
# 注册hc到cc
print "=============================================="
h = host(server,root_session)
#TODO 需要增加循环等待
self.assertTrue(h.query(START_INDEX,QUERY_COUNT,test_cluster,test_host))
# 设置tcu
print "=============================================="
# 获取刚刚注册的主机的cpu id
cpu_id = h.get_cpu_id(test_cluster,test_host)
self.assertNotEqual(cpu_id,None)
print "cpu id of host %s = %d" % (test_host,cpu_id)
s = tcu(server,root_session)
self.assertTrue(s.set(test_cluster,cpu_id,TCU_NUM2,"test cpu description"))
self.assertTrue(s.query(START_INDEX,QUERY_COUNT,test_cluster,"",cpu_id))
# 创建一个类型为1的用户组，用于容纳普通租户的账号
print "=============================================="
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate(test_tenant_usergroup,GROUP_TYPE1))
# 创建一个普通账号用于后续模拟来自租户的操作
u = user(server,root_session)
self.assertTrue(u.allocate(test_tenant_user,test_tenant_passwd,test_tenant_passwd,ACCOUNTUSER,test_tenant_usergroup))
# 使用普通租户账户登录tecs，获取该账户加密后的session
tenant_session = login(server,test_tenant_user,test_tenant_passwd)
self.assertNotEqual(tenant_session,None,"failed to get encrypted tenant session!")
# 使用ftp客户端上传一个虚拟机machine映像
ftp = FTP()
try:
ftp.connect(server_addr,21)
ftp.login(test_tenant_user,test_tenant_passwd)
except:
ci_exit_ex(-1,line(),"ftp login failed!")
print ftp.getwelcome()
try:
cmd='%s %s' % ("stor",os.path.basename(test_image))
ftp.storbinary(cmd,open(test_image,'rb'),1024)
except:
ci_exit_ex(-1,line(),"ftp upload failed!")
# 根据文件名获取刚刚上传的映像文件在tecs中的id
time.sleep(1)
i = image(server,tenant_session)
image_id = i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(image_id,None,"failed to get image id!")
# 设置一个网络平面
# 查询网络平面名称 不需要和设置的一样，有可能是下面上报的
# 配置DHCP
# 创建工程
p = project(server,tenant_session)
self.assertTrue(p.allocate(test_project_name,"test project description"))
# 创建虚拟机
cfg = {}
cfg_base = {}
cfg_base["vcpu"] = 2
cfg_base["tcu"] = 1
cfg_base["memory"] = long(128 * 1024 * 1024)
cfg_base["cluster"] = ""
cfg_base["host"] = ""
cfg_base["vm_wdtime"] = 0
cfg_base["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg_base["kernel"] = {"id":-1L,"size":0L}
cfg_base["ramdisk"] = {"id":-1L,"size":0L,"bus":"scsi"}
cfg_base["virt_type"] = "hvm"
cfg_base["root_device"] = ""
cfg_base["kernel_command"] = ""
cfg_base["rawdata"] = ""
cfg_base["context"] = {}
cfg["base_info"] = cfg_base
cfg["vm_name"] = test_vm_name
cfg["project_name"] = test_project_name
cfg["vm_num"] = 1
v = vmcfg(server,tenant_session)
self.assertTrue(v.allocate(cfg))
# 根据名称获取刚刚创建的虚拟机的id
vm_id = v.get_vm_id(test_vm_name)
self.assertNotEqual(vm_id,None,"failed to get vm id!")
# 获取虚拟机状态
vmstate = v.get_vm_state(vm_id)
self.assertNotEqual(vmstate,None,"failed to get vm state!")
#增加一个磁盘
disk1 = {"id":-1L,"size":long(512 * 1024 * 1024),"bus":"ide","type":"disk","target":"hdb","position":1,"fstype":"ext3"}
disks = [disk1]
self.assertTrue(v.set_disk(vm_id,disks))
#增加一个网卡
#nic1={"pci_order":0,"plane":"","vlan":0,"dhcp":bool(1),"ip":"10.43.180.250","netmask":"255.255.254.0","gateway":"10.43.180.1","mac":""}
#nics = [nic1]
#if v.set_nic(vm_id,nics) != True:
# ci_exit_ex(-1,line())
#等待tc上集群资源信息到位
count = 0
while (cm.query(START_INDEX,QUERY_COUNT,SYN_MODE) != True):
time.sleep(3)
count = count + 1
print "cluster query count = %d " %count
print "waiting for hc power on ..."
time.sleep(180)
# 部署虚拟机
self.assertTrue(v.action(vm_id,"deploy"))
# 获取虚拟机状态 应该是部署成功态，状态6为位置状态
count = 0
vm_state = U_STATE_UNKNOWN
while (v.get_vm_state(vm_id) != U_STATE_RUNNING and v.get_vm_state(vm_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count < 17)
# 重启虚拟机
self.assertTrue(v.action(vm_id,"reboot"))
# 获取虚拟机状态，应该为2
count = 0
vm_state = U_STATE_UNKNOWN
while (v.get_vm_state(vm_id) != U_STATE_RUNNING and v.get_vm_state(vm_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count < 17)
# 强制重启虚拟机
self.assertTrue(v.action(vm_id,"reset"))
# 获取虚拟机状态，应该为2
count = 0
vm_state = U_STATE_UNKNOWN
while (v.get_vm_state(vm_id) != U_STATE_RUNNING and v.get_vm_state(vm_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count < 17)
# 取消虚拟机
self.assertTrue(v.action(vm_id,"cancel"))
#取消需要3分钟，这里延时200秒
print "wait 200s"
time.sleep(200)
# 获取虚拟机状态，应该为0
count = 0
vm_state = U_STATE_UNKNOWN
while (v.get_vm_state(vm_id) != U_STATE_CONFIGURATION and v.get_vm_state(vm_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count < 17)
#再次部署虚拟机
self.assertTrue(v.action(vm_id,"deploy"))
# 获取虚拟机状态，应该为2
count = 0
vm_state = U_STATE_UNKNOWN
while (v.get_vm_state(vm_id) != U_STATE_RUNNING and v.get_vm_state(vm_id)!= None):
time.sleep(10)
count = count + 1
self.assertTrue(count < 17)
# 检测磁盘是否存在
# 检测网络是否通
# cancle虚拟机 应该成功
#测试结束
print "success to test test_001.py"
def suite():
suite = unittest.TestSuite()
suite.addTest(SmokingTestCase())
return suite
def testUserGroup(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
lognum = logqurey(server,root_session)
self.assertEqual(lognum,1)
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
print "test user and usergroup start......"
#创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
#创建一个用户组使用参数为 test_group1,2 应该失败
self.assertFalse(ug.allocate("test_group1",GROUP_TYPE2))
#查看test_group1 是否启用 应该为启用
self.assertEqual(ug.get_use_flag("test_group1"),UG_ENABLE)
#设置test_group1 为禁用
self.assertTrue(ug.set("test_group1",UG_DISABLE,"disable test_group1"))
#查看test_group1 是否启用 应该为禁用
self.assertEqual(ug.get_use_flag("test_group1"), UG_DISABLE)
#删除test_group1 用户组 应该成功
self.assertTrue(ug.delete("test_group1"))
#创建一个用户组使用参数为 test_group2,1 应该成功
self.assertTrue(ug.allocate("test_group2",GROUP_TYPE1))
#创建一个用户 参数为 test_cloud,test,test,1,test_group2 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("test_cloud","test","test",CLOUDADMIN,"test_group2"))
#设置test_group2 为禁用
self.assertTrue(ug.set("test_group2",UG_DISABLE,"disable test_group2"))
#使用 test_cloud 用户登录 应该失败
self.assertEqual(None,login(server,"test_cloud","test"))
#设置test_group2 为启用
self.assertTrue(ug.set("test_group2",UG_ENABLE,"enable test_group2"))
#需要重新登录
ns = login(server,"test_cloud","test")
nu = user(server,ns)
#使用 test_cloud 用户登录 应该成功
self.assertTrue(nu.query(START_INDEX,START_INDEX,"test_cloud"),"test_cloud can't login !")
#删除test_group2 用户组 应该失败
self.assertFalse(ug.delete("test_group2"))
#删除用户 参数为 test_cloud 应该成功
self.assertTrue(u.delete("test_cloud"))
#删除test_group2 用户组 应该成功
self.assertTrue(ug.delete("test_group2"))
#创建一个用户组使用参数为 test_group3,2 应该成功
self.assertTrue(ug.allocate("test_group3",GROUP_TYPE2))
#创建一个用户 参数为 test_cloud,aaaaaa,bbbbbb,1,test_group3 应该失败
self.assertFalse(u.allocate("test_cloud","aaaaaa","bbbbbb",CLOUDADMIN,"test_group3"))
#创建一个用户 参数为 test_cloud,aaaaaa,aaaaaa,1,test_group3 应该成功
self.assertTrue(u.allocate("test_cloud","aaaaaa","aaaaaa",CLOUDADMIN,"test_group3"))
#创建一个用户 参数为 test_cloud,aaaaaa,aaaaaa,1,test_group3 应该失败
self.assertFalse(u.allocate("test_cloud","aaaaaa","aaaaaa",CLOUDADMIN,"test_group3"))
#创建一个用户 参数为 test_account,aaaaaa,aaaaaa,2,test_group3 应该成功
self.assertTrue(u.allocate("test_account","aaaaaa","aaaaaa",ACCOUNTADMIN,"test_group3"))
#创建一个用户 参数为 test_user,aaaaaa,aaaaaa,3,test_group3 应该成功
self.assertTrue(u.allocate("test_user","aaaaaa","aaaaaa",ACCOUNTUSER,"test_group3"))
#创建一个用户组使用参数为 test_group4,2 应该成功
self.assertTrue(ug.allocate("test_group4",GROUP_TYPE2))
#创建一个用户 参数为 test_cloud,aaaaaa,aaaaaa,1,test_group3 应该失败
self.assertFalse(u.allocate("test_cloud","aaaaaa","aaaaaa",CLOUDADMIN,"test_group3"))
#创建一个用户 参数为 test_account,aaaaaa,aaaaaa,2,test_group3 应该失败
self.assertFalse(u.allocate("test_account","aaaaaa","aaaaaa",ACCOUNTADMIN,"test_group3"))
#创建一个用户 参数为 test_user,aaaaaa,aaaaaa,3,test_group3 应该失败
self.assertFalse(u.allocate("test_user","aaaaaa","aaaaaa",ACCOUNTUSER,"test_group3"))
# 管理员来修改租户信息
# 修改用户参数 参数为 "test_user","cccccc","cccccc",1,"test_group4",2,"13970581182","email","addr" 应当失败
# 611003123663 TC数据库整改，tecs.user.set接口增加description字段
self.assertFalse(u.set("test_user","cccccc","cccccc",CLOUDADMIN,"test_group4",\
USER_DISABLE,"13970581182","email","addr",NO_DESCRIPTION))
# 查询用户的描述
self.assertNotEqual(u.query_create_time(START_INDEX,QUERY_COUNT,"test_user"),None)
# 修改用户参数 参数为 "test_user","cccccc","cccccc",3,"test_group3",1,"","","",""应当成功
# 611003123663 TC数据库整改，tecs.user.set接口增加description字段
self.assertTrue(u.set("test_user","cccccc","cccccc", ACCOUNTUSER, "test_group3", USER_ENABLE,\
NO_PHONE, NO_EMAIL, NO_ADDR,NO_DESCRIPTION))
# 查询用户的电话 参数为 0,50,"test_user" 应该为 ""
self.assertEqual(u.query_phone(START_INDEX,QUERY_COUNT,"test_user"), NO_PHONE)
# 查询用户的email 参数为 0,50,"test_user" 应该为 ""
self.assertEqual(u.query_email(START_INDEX,QUERY_COUNT,"test_user"), NO_EMAIL)
# 查询用户的地址 参数为 0,50,"test_user" 应该为 ""
self.assertEqual(u.query_location(START_INDEX,QUERY_COUNT,"test_user"), NO_ADDR)
# 登录一个租户信息
encrypted_user_session = login(server,"test_user","cccccc")
if encrypted_user_session == None:
print "the encrypted_user_session is none "
self.assertNotEqual(encrypted_user_session,None,"failed to get encrypted root session!")
#测试王明辉新增加的两个接口：tecs.session.query 和 tecs.session.logout
self.assertTrue(logout(server,encrypted_user_session))
lognum = logqurey(server,root_session)
print "the lognum is %d" %lognum
# 登录一个租户信息
encrypted_user_session = login(server,"test_user","cccccc")
self.assertNotEqual(encrypted_user_session,None,"failed to get encrypted root session!")
ur = user(server,encrypted_user_session)
# 修改用户参数 参数为 "test_user","","", 3, "", 1,"13970581182","email","addr" 应当成功
# 611003123663 TC数据库整改，tecs.user.set接口增加description字段
self.assertTrue(ur.set("test_user", "", "", ACCOUNTUSER, "", USER_ENABLE,\
"13970581182", "email", "addr","hello, world!"))
# 查询用户的描述 应该为"hello, world!"
self.assertEqual(u.query_description(START_INDEX,QUERY_COUNT,"test_user"), "hello, world!")
# 查询用户的电话 参数为 0,50,"test_user" 应该为 "13970581182"
self.assertEqual(ur.query_phone(START_INDEX,QUERY_COUNT,"test_user"), "13970581182")
# 查询用户的email 参数为 0,50,"test_user" 应该为 "email"
self.assertEqual(ur.query_email(START_INDEX,QUERY_COUNT,"test_user"), "email")
# 查询用户的地址 参数为 0,50,"test_user" 应该为 "addr"
self.assertEqual(ur.query_location(START_INDEX,QUERY_COUNT,"test_user"), "addr")
# 修改用户参数 参数为 "test_user","cccccc1","cccccc1",3,"test_group3",1,"13970581181","email1","addr1" 应当成功
# 611003123663 TC数据库整改，tecs.user.set接口增加description字段
self.assertTrue(ur.set("test_user","cccccc1","cccccc1",ACCOUNTUSER,"test_group3",\
USER_ENABLE,"13970581181","email1","addr1",NO_DESCRIPTION))
# 使用修改后的密码登录"test_user"
encrypted_user1_session = login(server,"test_user","cccccc1")
self.assertNotEqual(encrypted_user1_session,None,"failed to get encrypted root session!")
ur1 = user(server,encrypted_user1_session)
# 查询用户的电话 参数为 0,50,"test_user" 应该为 "13970581181"
self.assertEqual(ur1.query_phone(START_INDEX,QUERY_COUNT,"test_user"), "13970581181")
# 查询用户的email 参数为 0,50,"test_user" 应该为 "email1"
self.assertEqual(ur1.query_email(START_INDEX,QUERY_COUNT,"test_user"), "email1")
# 查询用户的地址 参数为 0,50,"test_user" 应该为 "addr1"
self.assertEqual(ur1.query_location(START_INDEX,QUERY_COUNT,"test_user"), "addr1")
# 租户权限修改非法参数
# 修改用户参数 参数为 "test_user","cccccc1","cccccc1",1,"test_group3",1,"13970581181","email1","addr1" 应当失败
# 611003123663 TC数据库整改，tecs.user.set接口增加description字段
self.assertFalse(ur1.set("test_user","cccccc1","cccccc1",CLOUDADMIN,"test_group3",\
USER_ENABLE,"13970581181","email1","addr1",NO_DESCRIPTION))
# 修改用户参数 参数为 "test_user","cccccc1","cccccc1",3,"test_group3",2,"13970581181","email1","addr1" 应当失败
# 611003123663 TC数据库整改，tecs.user.set接口增加description字段
self.assertFalse(ur1.set("test_user","cccccc1","cccccc1",ACCOUNTUSER,"test_group3",\
USER_DISABLE,"13970581181","email1","addr1",NO_DESCRIPTION))
#删除用户 参数为 test_cloud 应该成功
self.assertTrue(u.delete("test_cloud"))
#删除用户 参数为 test_account 应该成功
self.assertTrue(u.delete("test_account"))
#删除用户 参数为 test_user 应该成功
self.assertTrue(u.delete("test_user"))
#删除test_group3 用户组 应该成功
self.assertTrue(ug.delete("test_group3"))
#删除test_group4 用户组 应该成功
self.assertTrue(ug.delete("test_group4"))
#测试结束
print "success to test test_003_user_group.py"
def suite():
suite = unittest.TestSuite()
suite.addTest(UserGroupTestCase())
return suite
if o in ("-u", "--user"):
root_user = v
__builtin__.LOG = server_addr.replace('.','_')
#登录映像管理模块
encrypted_root_session, server = login_user(server_addr,root_user) #//蓝色字体部分为范本，每个.py文件中基本都是这样的！直接从范例中拷贝！
##############################################################
##############################################################
#######ST-F_USABILITY-OSSetup02 创建，修改，删除和查询帐户测试##########
st_log(2,'',"START")
#登录用户管理模块
u = user(server,encrypted_root_session)
ug = usergroup(server,encrypted_root_session)
#用例开始
result = True
#创建用户组usergroup0和usergroup1, 应该成功
for i in range(2):
mygroup = "usergroup"+str(i)
if ug.allocate(mygroup,1) != True:
st_log(-1,lines(),"ST-F_USABILITY-OSSetup01: mygroup can not create!")
result = False
#并设置用户组usergroup0为禁用，应该成功
if ug.set("usergroup0",2,"disable usergroup0") != True:
st_log(-1,lines(),"ST-F_USABILITY-OSSetup01: set usergroup0 is failed !")
result = False
def testVmt(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
# 创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
# 创建一个用户 参数为 user,test,test,3,test_group1 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("user","test","test",ACCOUNTUSER,"test_group1"))
# 登录租户 获取租户session 以备后面使用
user_session = login(server,"user","test")
self.assertNotEqual(user_session, None,"failed to get user session!")
# 以管理员身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,test_root_user,test_root_passwd,test_image),"failed to upload_image_file!")
# 以租户身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,"user","test",test_image),"failed to upload_image_file!")
# 注册集群
root_cluster_manager_method = clustermanager(server,root_session)
self.assertTrue(root_cluster_manager_method.query(START_INDEX,QUERY_COUNT,SYN_MODE))
# 注册主机
root_host_method = host(server,root_session)
# 等待 20S 等待资源上报
#time.sleep(20)
self.assertTrue(root_host_method.query(START_INDEX,QUERY_COUNT,test_cluster,test_host))
# 设置tcu 8
cpu_id = root_host_method.get_cpu_id(test_cluster,test_host)
self.assertNotEqual(cpu_id, None)
print "cpu id of host %s = %d" % (test_host,cpu_id)
root_tcu_method = tcu(server,root_session)
self.assertTrue(root_tcu_method.set(test_cluster,cpu_id,TCU_NUM8,"test cpu description"))
self.assertTrue(root_tcu_method.query(START_INDEX,QUERY_COUNT,test_cluster,NO_CPU_INFO,cpu_id))
# 注册image
# 根据文件名获取刚刚上传的映像文件在tecs中的id
i = image(server,root_session)
image_id = i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(image_id, None, "failed to get image id!")
# 创建工程
user_project = project(server,user_session)
self.assertTrue(user_project.allocate(test_project_name,"test project description"))
root_project = project(server,root_session)
self.assertTrue(root_project.allocate(test_project_name,"test project description"))
# ------------------管理员自身权限测试------------------
# 创建模板测试
# 测试使用快速创建接口来进行创建参数如下： 应该成功
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 2
cfg["base_info"]["memory"] = long(128 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
#cfg["base_info"]["disks"] = [{"id":-1L,"size":long(256 * 1024 * 1024),"bus":"scsi","type":"disk","target":"sdb","position":1,"fstype":"ext2"}]
vt = vmtemplate(server,root_session)
self.assertFalse(vt.allocate(cfg))
# 发布image
#Vmtemplate cannot public, for Image( -1 ) not public
self.assertTrue(i.publish(image_id,IS_PUBLIC))
# 创件模板： 应该成功
self.assertTrue(vt.allocate(cfg))
#EC611002997307 创建模板时，如果名称冲突，报的是参数错误，不直观
#创建相同名称的模板，返回错误参数
self.assertFalse(vt.allocate(cfg))
# 删除虚拟机模板 参数为 test_vt_name 应当成功
self.assertTrue(vt.del_vmt(test_vt_name))
# 测试使用快速创建接口来进行创建参数如下： 应该成功
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 2
cfg["base_info"]["memory"] = long(128 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"scsi","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
self.assertTrue(vt.allocate(cfg))
# 删除虚拟机模板 参数为 test_vt_name 应当成功
self.assertTrue(vt.del_vmt(test_vt_name))
# 测试使用快速创建接口来进行创建参数如下： 应该成功
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 2
cfg["base_info"]["memory"] = long(128 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"scsi","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
self.assertTrue(vt.allocate(cfg))
# 创建磁盘 参数如下 应当成功
user_i = image(server,user_session)
user_image_id = user_i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(user_image_id, None, "failed to get image id!")
self.assertTrue(i.publish(user_image_id,IS_PUBLIC))
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 4
cfg["base_info"]["memory"] = long(256 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":user_image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
cfg["base_info"]["context"] = {}
cfg["base_info"]["qualifications"] = []
#cfg["base_info"]["disks"] = [{"id":-1L,"size":long(256 * 1024 * 1024),"bus":"scsi","type":"disk","target":"xvdb","position":0,"fstype":"ext2"}]
disk1 = {"id":-1L,"size":long(128 * 1024 * 1024),"bus":"ide","type":"disk","target":"hdb","position":1,"fstype":"ext3"}
# test_vt_name 和 disks = [disk1]
cfg["base_info"]["disks"] = [disk1]
self.assertTrue(vt.set(cfg))
# 创建磁盘 参数如下 应当成功
disk2 = {"id":-1L,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"disk","target":"sdb","position":1,"fstype":"ext4"}
# test_vt_name 和 disks = [disk2]
cfg["base_info"]["disks"] = [disk2]
self.assertTrue(vt.set(cfg))
# 创建磁盘 参数如下 应当成功
disk3 = {"id":-1L,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"disk","target":"sdd","position":2,"fstype":"ext4"}
# test_vt_name 和 disks = [disk3]
cfg["base_info"]["disks"] = [disk3]
self.assertTrue(vt.set(cfg))
# 创建image disk 应当成功,ramdisk暂时没有使用，不测试
disk4 = {"id":image_id,"position":1,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"datablock","target":"sde"}
#if vt.set(cfg) != True:
# ci_exit_ex(-1,line())
# 创建image disk 应当成功,ramdisk暂时没有使用，不测试
disk5 = {"id":image_id,"position":1,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"cdrom","target":"sdf"}
#if vt.set(cfg) != True:
# ci_exit_ex(-1,line())
# 创建image disk 应当失败，,ramdisk暂时没有使用，不测试
disk6 = {"id":image_id,"position":1,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"disk","target":"sdf"}
#if vt.set(cfg) != False:
# ci_exit_ex(-1,line())
# 创建磁盘 参数如下 应当失败，
disk7 = {"id":-1L,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"disk","target":"sdd","position":2,"fstype":"fat32"}
# test_vt_name 和 disks = [disk7]
cfg["base_info"]["disks"] = [disk7]
self.assertFalse(vt.set(cfg))
# 创建磁盘 参数如下 应当成功，
disk8 = {"id":-1L,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"cdrom","target":"sdd","position":2,"fstype":"ext4"}
# test_vt_name 和 disks = [disk8]
cfg["base_info"]["disks"] = [disk8]
self.assertTrue(vt.set(cfg))
# 创建磁盘 参数如下 应当成功
disk9 = {"id":-1L,"size":long(128 * 1024 * 1024),"bus":"scsi","type":"disk","target":"sdg","position":2,"fstype":"ext2"}
# test_vt_name 和 disks = [disk9]
cfg["base_info"]["disks"] = [disk9]
self.assertTrue(vt.set(cfg))
# 创建磁盘 参数如下 应当成功
# test_vt_name 和 disks = [disk1 disk2 disk3 disk4 disk9]
cfg["base_info"]["disks"] = [disk1,disk2,disk3,disk9]
self.assertTrue(vt.set(cfg))
# 创建磁盘 参数如下 应当失败
# test_vt_name 和 disks = [disk1 disk1]
cfg["base_info"]["disks"] = [disk1,disk1]
self.assertFalse(vt.set(cfg))
# 删除虚拟机模板 参数为 test_vt_name 应当成功
self.assertTrue(vt.del_vmt(test_vt_name))
self.assertTrue(i.publish(user_image_id,NOT_PUBLIC))
# 创建网口 参数如下 应当成功
#EC611003123662 TC数据库整改 gaom 2012-07-30 增加nic_index字段用例
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 4
cfg["base_info"]["memory"] = long(256 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
cfg["base_info"]["context"] = {}
cfg["base_info"]["qualifications"] = []
nic1 = {"nic_index":0,"sriov":bool(0),"loop":bool(0),"logic_network_id":"logic_network_1"}
cfg["base_info"]["nics"] = [nic1]
#创建模板，应该成功
self.assertTrue(vt.allocate(cfg))
nic_index = vt.query_nics_index(QUERY_BY_VT_NAME,test_vt_name,QUERY_FIRST_NIC)
self.assertNotEqual(nic_index, 0)
# 删除虚拟机模板 参数为 test_vt_name 应当成功
self.assertTrue(vt.del_vmt(test_vt_name))
#创建两个相同的nic_index网卡的模板，应该失败
nic1 = {"nic_index":1,"sriov":bool(0),"loop":bool(0),"logic_network_id":"logic_network_1"}
nic2 = {"nic_index":1,"sriov":bool(0),"loop":bool(0),"logic_network_id":"logic_network_1"}
cfg["base_info"]["nics"] =[nic1,nic2]
self.assertFalse(vt.allocate(cfg))
#创建两个不同的nic_index网卡的模板，应该成功
nic1 = {"nic_index":0,"sriov":bool(0),"loop":bool(0),"logic_network_id":"logic_network_1"}
nic2 = {"nic_index":2,"sriov":bool(0),"loop":bool(0),"logic_network_id":"logic_network_1"}
cfg["base_info"]["nics"] =[nic1,nic2]
self.assertTrue(vt.allocate(cfg))
#查询两个网卡的index，应该不同
#nic_index0 = vt.query_nics_index(QUERY_BY_VT_NAME,test_vt_name,QUERY_FIRST_NIC)
#nic_index1 = vt.query_nics_index(QUERY_BY_VT_NAME,test_vt_name,QUERY_SECOND_NIC)
#self.assertNotEqual(nic_index0, nic_index1)
#删除模板 成功
self.assertTrue(vt.del_vmt(test_vt_name))
#添加EC611003050917：模板管理中创建或修改看门狗时长修改不成功，始终是0
# 修改vm_wdtime为0 应该失败
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 2
cfg["base_info"]["memory"] = long(128 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
cfg["base_info"]["disks"] = [disk1]
cfg["base_info"]["vm_wdtime"] = 0
self.assertTrue(vt.allocate(cfg) )
# 查询vm_wdtime： 应该为0
self.assertEqual(vt.query_vm_wdtime(QUERY_BY_VT_NAME,test_vt_name),0)
# 修改vm_wdtime为1 应该失败
cfg["base_info"]["vm_wdtime"] = 1
self.assertFalse(vt.set(cfg))
# 修改vm_wdtime为599 应该失败
cfg["base_info"]["vm_wdtime"] = 599
self.assertFalse(vt.set(cfg))
# 修改vm_wdtime为600 应该成功
cfg["base_info"]["vm_wdtime"] = 600
self.assertTrue(vt.set(cfg))
# 查询vm_wdtime： 应该为600
self.assertEqual(vt.query_vm_wdtime(QUERY_BY_VT_NAME,test_vt_name),600)
# 修改vm_wdtime为999999 应该成功
cfg["base_info"]["vm_wdtime"] = 999999
self.assertTrue(vt.set(cfg))
# 查询vm_wdtime： 应该为999999
self.assertEqual(vt.query_vm_wdtime(QUERY_BY_VT_NAME,test_vt_name), 999999)
# 删除虚拟机模板 参数为 test_vt_name 应当成功
self.assertTrue(vt.del_vmt(test_vt_name))
# 增加映像2，类型为Datablock，使能， 应当成功
#新建模板， 基于映像2创建Datablock类型的磁盘， 应当失败：611003248365
self.assertTrue(i.enable(user_image_id,I_ENABLE))
self.assertTrue(i.publish(user_image_id,IS_PUBLIC))
self.assertTrue(i.set(image_id, NO_IMAGE_NAME, "datablock", NO_IMAGE_ARCH, "ide", NO_IMAGE_DESCRIPTION,"Linux"))
self.assertTrue(i.enable(image_id,I_ENABLE))
cfg = {}
cfg["vt_name"] = test_vt_name
cfg["is_public"] = bool(1)
cfg["base_info"] = {}
cfg["base_info"]["vcpu"] = 2
cfg["base_info"]["memory"] = long(128 * 1024 * 1024)
cfg["base_info"]["machine"] = {"id":user_image_id,"position":1,"size":0L,"bus":"scsi","type":"machine","target":"hda"}
cfg["base_info"]["virt_type"] = "hvm"
cfg["base_info"]["root_device"] = ""
cfg["base_info"]["kernel_command"] = ""
cfg["base_info"]["rawdata"] = ""
cfg["base_info"]["disks"] = [{"id":image_id,"position":1,"size":0L,"bus":"scsi","type":"datablock","target":"sdb"}]
def testVm(self):
# ------------------环境准备------------------
# 登录tecs，获取管理员账户加密后的session
root_session = login(server,test_root_user,test_root_passwd)
self.assertNotEqual(root_session,None,"failed to get encrypted root session!")
#系统运行状态查询 EC:611003077308 tecs提供rpc接口查询系统运行时信息
#此处延时20s，否则hc的MU_VM_HANDLER和MU_HOST_HEARTBEAT不存在
time.sleep(100)
#必须是管理员账户
sys_runtime_query = tecssystem(server,root_session)
#查询TC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,DEFAULT_TC)),RUNTIME_STATE_NORMAL,"tc status is abnormal")
#查询CC状态
self.assertEqual(int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cluster)),RUNTIME_STATE_NORMAL,"cc status is abnormal")
#查询HC状态
test_cc_hc = test_cluster + "," + test_host
hc_state = int(sys_runtime_query.get_runtime_state(TYPE_CACULATE,test_cc_hc))
self.assertTrue(hc_state >= RUNTIME_STATE_NORMAL and hc_state <= RUNTIME_STATE_WARNNING,"hc status is abnormal")
# 创建一个用户组使用参数为 test_group1,1 ,应该成功
ug = usergroup(server,root_session)
self.assertTrue(ug.allocate("test_group1",GROUP_TYPE1))
# 创建一个用户 参数为 user,test,test,3,test_group1 应该成功
u = user(server,root_session)
self.assertTrue(u.allocate("user","test","test",ACCOUNTUSER,"test_group1"))
# 登录租户 获取租户session 以备后面使用
user_session = login(server,"user","test")
self.assertNotEqual(user_session, None,"failed to get user session!")
# 以管理员身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,test_root_user,test_root_passwd,test_image),"failed to upload_image_file!")
# 以租户身份上传一个映像文件 应该成功
self.assertTrue(upload_image_file(server_addr,"user","test",test_image),"failed to upload_image_file!")
# 注册集群
root_cluster_manager_method = clustermanager(server,root_session)
self.assertTrue(root_cluster_manager_method.query(START_INDEX,QUERY_COUNT,SYN_MODE))
# 注册主机
root_host_method = host(server,root_session)
# 等待 20S 等待资源上报
#time.sleep(20)
self.assertTrue(root_host_method.query(START_INDEX,QUERY_COUNT,test_cluster,test_host))
# 设置tcu 8
cpu_id = root_host_method.get_cpu_id(test_cluster,test_host)
self.assertNotEqual(cpu_id, None)
print "cpu id of host %s = %d" % (test_host,cpu_id)
root_tcu_method = tcu(server,root_session)
self.assertTrue(root_tcu_method.set(test_cluster,cpu_id,TCU_NUM8,"test cpu description"))
self.assertTrue(root_tcu_method.query(START_INDEX,QUERY_COUNT,test_cluster,NO_CPU_INFO,cpu_id))
# 注册image
# 根据文件名获取刚刚上传的映像文件在tecs中的id
i = image(server,root_session)
image_id = i.get_id_by_filename(os.path.basename(test_image))
self.assertNotEqual(image_id, None, "failed to get image id!")
self.assertTrue(i.publish(image_id,IS_PUBLIC))
# 创建工程
user_project = project(server,user_session)
self.assertTrue(user_project.allocate(test_project_name2,"test project description"))
root_project = project(server,root_session)
self.assertTrue(root_project.allocate(test_project_name,"test project description"))
user_project = project(server,user_session)
self.assertTrue(user_project.allocate(test_project_name,"test project description"))
# ------------------管理员自身权限测试------------------
# 使用虚拟机模板创建虚拟机，在虚拟机模板测试流程中已经测试过了
# test_project_name下直接创建虚拟机vm_001
# 使用参数如下： 应当成功
cfg_base = {}
cfg_base["vcpu"] = 1
cfg_base["tcu"] = 1
cfg_base["memory"] = long(128 * 1024 * 1024)
cfg_base["cluster"] = ""
cfg_base["host"] = ""
cfg_base["vm_wdtime"] = 0
cfg_base["machine"] = {"id":image_id,"position":1,"size":0L,"bus":"ide","type":"machine","target":"hda"}
cfg_base["kernel"] = {"id":-1L,"size":0L}
cfg_base["ramdisk"] = {"id":-1L,"size":0L,"bus":"scsi"}
cfg_base["virt_type"] = "hvm"
cfg_base["root_device"] = ""
cfg_base["kernel_command"] = ""
cfg_base["rawdata"] = ""
cfg_base["context"] = {}
cfg_base["qualifications"] = []
cfg_base["disks"] = [{"id":-1L,"size":long(128 * 1024 * 1024),"bus":"ide","type":"disk","target":"hdb","position":1,"fstype":"ext3"}]
