def deploy_ceilometer_ha_with_external_mongo(self):
"""Deploy cluster in ha mode with Ceilometer and external Mongo
Scenario:
1. Create cluster. Set install Ceilometer, external Mongo option
2. Add 3 node with controller role
3. Add 1 nodes with compute and ceph roles
4. Add 1 node with ceph role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_external_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'tenant': 'ceilometerHA',
'user': '******',
'password': '******',
'net_provider': 'neutron',
'net_segment_type': 'tun',
'volumes_ceph': True,
'images_ceph': True,
'volumes_lvm': False,
'osd_pool_size': "2",
'mongo': True,
'hosts_ip': settings.SERVTEST_EXTERNAL_MONGO_URLS,
'mongo_db_name': settings.SERVTEST_EXTERNAL_MONGO_DB_NAME,
'mongo_user': settings.SERVTEST_EXTERNAL_MONGO_USER,
'mongo_password': settings.SERVTEST_EXTERNAL_MONGO_PASS,
'mongo_replset': settings.SERVTEST_EXTERNAL_MONGO_REPL_SET
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute', 'ceph-osd'],
'slave-05': ['ceph-osd']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_with_external_mongo")
def deploy_ceilometer_simple_multirole(self):
"""Deploy cluster in simple multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 2 nodes with cinder and mongo roles
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Snapshot: deploy_ceilometer_simple_multirole
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__, settings={'ceilometer': True})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder', 'mongo']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_simple_mulirole")
def deploy_ceilometer_ha_one_controller_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 2 nodes with cinder and mongo roles
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 35m
Snapshot: deploy_ceilometer_ha_one_controller_multirole
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={"ceilometer": True, "net_provider": "neutron", "net_segment_type": "tun"},
)
self.fuel_web.update_nodes(
cluster_id, {"slave-01": ["controller"], "slave-02": ["compute"], "slave-03": ["cinder", "mongo"]}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")["ip"]
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote, service_name="ceilometer-api")
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_one_controller_multirole")
def deploy_ceilometer_ha_with_external_mongo(self):
"""Deploy cluster in ha mode with Ceilometer and external Mongo
Scenario:
1. Create cluster. Set install Ceilometer, external Mongo option
2. Add 3 node with controller role
3. Add 1 nodes with compute and ceph roles
4. Add 1 node with ceph role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_external_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'tenant': 'ceilometerHA',
'user': '******',
'password': '******',
'net_provider': 'neutron',
'net_segment_type': 'tun',
'volumes_ceph': True,
'images_ceph': True,
'volumes_lvm': False,
'osd_pool_size': "2",
'mongo': True,
'hosts_ip': settings.SERVTEST_EXTERNAL_MONGO_URLS,
'mongo_db_name': settings.SERVTEST_EXTERNAL_MONGO_DB_NAME,
'mongo_user': settings.SERVTEST_EXTERNAL_MONGO_USER,
'mongo_password': settings.SERVTEST_EXTERNAL_MONGO_PASS,
'mongo_replset': settings.SERVTEST_EXTERNAL_MONGO_REPL_SET
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute', 'ceph-osd'],
'slave-05': ['ceph-osd']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(_ip,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_with_external_mongo")
def deploy_ceilometer_ha_with_external_mongo(self):
"""Deploy cluster in ha mode with Ceilometer and external Mongo
Scenario:
1. Create cluster. Set install Ceilometer, external Mongo option
2. Add 3 node with controller role
3. Add 1 nodes with compute and ceph roles
4. Add 1 node with ceph role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_external_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"ceilometer": True,
"tenant": "ceilometerHA",
"user": "******",
"password": "******",
"net_provider": "neutron",
"net_segment_type": "tun",
"volumes_ceph": True,
"images_ceph": True,
"volumes_lvm": False,
"osd_pool_size": "2",
"mongo": True,
"hosts_ip": settings.SERVTEST_EXTERNAL_MONGO_URLS,
"mongo_db_name": settings.SERVTEST_EXTERNAL_MONGO_DB_NAME,
"mongo_user": settings.SERVTEST_EXTERNAL_MONGO_USER,
"mongo_password": settings.SERVTEST_EXTERNAL_MONGO_PASS,
"mongo_replset": settings.SERVTEST_EXTERNAL_MONGO_REPL_SET,
},
)
self.fuel_web.update_nodes(
cluster_id,
{
"slave-01": ["controller"],
"slave-02": ["controller"],
"slave-03": ["controller"],
"slave-04": ["compute", "ceph-osd"],
"slave-05": ["ceph-osd"],
},
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")["ip"]
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote, service_name="ceilometer-api")
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_with_external_mongo")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run ostf
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
'ceilometer': True,
'tenant': 'ceilometerHA',
'user': '******',
'password': '******'
})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['ha', 'smoke', 'sanity'],
should_fail=2,
timeout=5300,
failed_test_name=[
'Create volume and boot instance from it',
'Create volume and attach it to instance'
])
# run platfrom tests
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['platform_tests'],
should_fail=4,
timeout=5300,
failed_test_name=['Check stack autoscaling'])
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run ostf
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
'ceilometer': True,
'tenant': 'ceilometerHA',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['ha', 'smoke', 'sanity'],
should_fail=2, timeout=5300,
failed_test_name=['Create volume and boot instance from it',
'Create volume and attach it to instance'])
# run platfrom tests
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['platform_tests'],
should_fail=4, timeout=5300,
failed_test_name=['Check stack autoscaling'])
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def check_services_on_nodes(self, services, node_role):
node_ips = [
node["ip"] for node in
self.fuel_web.get_nailgun_cluster_nodes_by_roles(
self.helpers.cluster_id, [node_role])]
logger.info("Check {} services on {} nodes".format(
services, node_role))
for ip in node_ips:
for service in services:
fuelweb_checkers.verify_service(
ip, service, ignore_count_of_proccesses=True)
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in simple mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run ostf
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("deploy_mongo_available")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings={
'ceilometer': True
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf smoke and sanity
self.fuel_web.run_ostf(
cluster_id=cluster_id,
should_fail=1)
# run ostf platform
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['platform_tests', 'ha'],
should_fail=2, timeout=3500,
failed_test_name=['Create volume and attach it to instance',
'Check stack autoscaling'])
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
'tenant': 'ceilometerHA',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
self.run_tests(cluster_id,
skip_tests=['test_check_volume_notifications'])
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_ha_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller and mongo roles
3. Add 1 nodes with compute role
4. Add 1 nodes with cinder
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run ostf
Snapshot: deploy_ceilometer_ha_multirole
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
'ceilometer': True
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['controller', 'mongo'],
'slave-03': ['controller', 'mongo'],
'slave-04': ['compute'],
'slave-05': ['cinder']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke', 'sanity', 'ha'],
should_fail=0, timeout=5300)
# run platform test
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['platform_tests'],
should_fail=3, timeout=5300)
self.env.make_snapshot("deploy_ceilometer_ha_mulirole")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
'tenant': 'ceilometerHA',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(_ip,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
self.run_tests(cluster_id,
skip_tests=['test_check_volume_events'])
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_simple_with_mongo(self):
"""Deploy cluster in simple mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with cinder role
5. Add 1 node with mongo role
6. Deploy the cluster
7. Verify ceilometer api is running
8. Run ostf
Snapshot: deploy_ceilometer_simple_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings={
'ceilometer': True,
'tenant': 'ceilometerSimple',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder'],
'slave-04': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke', 'sanity',
'platform_tests'],
should_fail=1, timeout=5300)
self.env.make_snapshot("deploy_ceilometer_simple_with_mongo")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"ceilometer": True,
"net_provider": "neutron",
"net_segment_type": "tun",
"tenant": "ceilometerHA",
"user": "******",
"password": "******",
},
)
self.fuel_web.update_nodes(
cluster_id,
{
"slave-01": ["controller"],
"slave-02": ["controller"],
"slave-03": ["controller"],
"slave-04": ["compute"],
"slave-05": ["mongo"],
},
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")["ip"]
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote, service_name="ceilometer-api")
self.run_tests(cluster_id, skip_tests=["test_check_volume_notifications"])
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_simple_with_mongo(self):
"""Deploy cluster in simple mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with cinder role
5. Add 1 node with mongo role
6. Deploy the cluster
7. Verify ceilometer api is running
8. Run ostf
Snapshot: deploy_ceilometer_simple_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
settings={
'ceilometer':
True,
'tenant':
'ceilometerSimple',
'user':
'******',
'password':
'******'
})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder'],
'slave-04': ['mongo']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['smoke', 'sanity', 'platform_tests'],
should_fail=1,
timeout=5300)
self.env.make_snapshot("deploy_ceilometer_simple_with_mongo")
def deploy_ceilometer_ha_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller and mongo roles
3. Add 1 nodes with compute role
4. Add 1 nodes with cinder
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 80m
Snapshot: deploy_ceilometer_ha_multirole
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['controller', 'mongo'],
'slave-03': ['controller', 'mongo'],
'slave-04': ['compute'],
'slave-05': ['cinder']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_multirole", is_make=True)
def deploy_ceilometer_ha_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller and mongo roles
3. Add 1 nodes with compute role
4. Add 1 nodes with cinder
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run ostf
Snapshot: deploy_ceilometer_ha_multirole
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={'ceilometer': True})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller', 'mongo'],
'slave-02': ['controller', 'mongo'],
'slave-03': ['controller', 'mongo'],
'slave-04': ['compute'],
'slave-05': ['cinder']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
# run ostf
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['smoke', 'sanity', 'ha'],
should_fail=0,
timeout=5300)
# run platform test
self.fuel_web.run_ostf(cluster_id=cluster_id,
test_sets=['platform_tests'],
should_fail=3,
timeout=5300)
self.env.make_snapshot("deploy_ceilometer_ha_mulirole")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 65m
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'tenant': 'ceilometerHA',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_simple(self):
"""Deploy cluster in simple mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with cinder role
4. Deploy the cluster
5. Verify ceilometer api is running
6. Run ostf
Snapshot: deploy_ceilometer_simple
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings={
'ceilometer': True
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready(
'slave-01', smiles_count=6, networks_count=1, timeout=300)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
self.fuel_web.run_ostf(
cluster_id=cluster_id,
should_fail=4)
self.env.make_snapshot("deploy_ceilometer_simple")
def deploy_ceilometer_ha_with_mongo(self):
"""Deploy cluster in ha mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with mongo role
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Snapshot: deploy_ceilometer_ha_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
'ceilometer': True,
'tenant': 'ceilometerHA',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_with_mongo")
def deploy_ceilometer_ha_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 3 node with controller and mongo roles
3. Add 1 nodes with compute role
4. Add 1 nodes with cinder
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 80m
Snapshot: deploy_ceilometer_ha_multirole
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller', 'mongo'],
'slave-02': ['controller', 'mongo'],
'slave-03': ['controller', 'mongo'],
'slave-04': ['compute'],
'slave-05': ['cinder']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_multirole", is_make=True)
def deploy_ceilometer_simple_multirole(self):
"""Deploy cluster in simple multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 2 nodes with cinder and mongo roles
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Snapshot: deploy_ceilometer_simple_multirole
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings={
'ceilometer': True
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder', 'mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke', 'sanity',
'platform_tests'],
timeout=5300)
self.env.make_snapshot("deploy_ceilometer_simple_mulirole")
def deploy_ceilometer_ha_one_controller_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 2 nodes with cinder and mongo roles
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 35m
Snapshot: deploy_ceilometer_ha_one_controller_multirole
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder', 'mongo']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
for service_name in SERVICES_TO_CHECK:
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(_ip,
service_name=service_name,
ignore_count_of_proccesses=True)
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_one_controller_multirole")
def deploy_ceilometer_ha_one_controller_multirole(self):
"""Deploy cluster in ha multirole mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 2 nodes with cinder and mongo roles
5. Deploy the cluster
6. Verify ceilometer api is running
7. Run OSTF
Duration 35m
Snapshot: deploy_ceilometer_ha_one_controller_multirole
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder', 'mongo']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
self.run_tests(cluster_id)
self.env.make_snapshot("deploy_ceilometer_ha_one_controller_mulirole")
def deploy_ceilometer_ha_one_controller_with_mongo(self):
"""Deploy cluster in HA mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with cinder role
5. Add 1 node with mongo role
6. Deploy the cluster
7. Verify ceilometer api is running
8. Run OSTF
Duration 45m
Snapshot: deploy_ceilometer_ha_one_controller_with_mongo
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
'tenant': 'ceilometerSimple',
'user': '******',
'password': '******'
})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute', 'cinder'],
'slave-03': ['mongo']
})
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
disk_mb = 0
for node in nailgun_nodes:
if node.get('pending_roles') == ['mongo']:
disk_mb = self.fuel_web.get_node_disk_size(
node.get('id'), "vda")
LOGGER.debug('disk size is {0}'.format(disk_mb))
mongo_disk_mb = 11116
os_disk_mb = disk_mb - mongo_disk_mb
mongo_disk_gb = ("{0}G".format(round(mongo_disk_mb / 1024, 1)))
disk_part = {"vda": {"os": os_disk_mb, "mongo": mongo_disk_mb}}
for node in nailgun_nodes:
if node.get('pending_roles') == ['mongo']:
self.fuel_web.update_node_disk(node.get('id'), disk_part)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-03")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
partitions = checkers.get_mongo_partitions(remote, "vda5")
assert_equal(
partitions[0].rstrip(), mongo_disk_gb,
'Mongo size {0} before deployment is not equal'
' to size after {1}'.format(mongo_disk_gb, partitions))
self.run_tests(cluster_id)
self.env.make_snapshot(
"deploy_ceilometer_ha_one_controller_with_mongo")
def deploy_sahara_ha_one_controller_tun(self):
"""Deploy cluster in ha mode with 1 controller Sahara and Neutron VXLAN
Scenario:
1. Create a Fuel cluster. Set the option for Sahara installation
2. Add 1 node with "controller" role
3. Add 1 node with "compute" role
4. Deploy the Fuel cluster
5. Verify Sahara service on controller
6. Run all sanity and smoke tests
7. Register Vanilla2 image for Sahara
8. Run platform Vanilla2 test for Sahara
Duration 65m
Snapshot: deploy_sahara_ha_one_controller_tun
"""
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Create Fuel cluster for Sahara tests')
data = {
'sahara': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'saharaSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id), data['user'],
data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=5)
LOGGER.debug('Verify Sahara service on controller')
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote, service_name='sahara-api')
checkers.verify_service(remote, service_name='sahara-engine')
LOGGER.debug('Check MD5 sum of Vanilla2 image')
check_image = checkers.check_image(
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
LOGGER.debug('Run all sanity and smoke tests')
path_to_tests = 'fuel_health.tests.sanity.test_sanity_sahara.'
test_names = [
'VanillaTwoTemplatesTest.test_vanilla_two_templates',
'HDPTwoTemplatesTest.test_hdp_two_templates'
]
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=[
path_to_tests + test_name for test_name in test_names
])
LOGGER.debug('Import Vanilla2 image for Sahara')
with open('{0}/{1}'.format(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE)) as data:
os_conn.create_image(
name=settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_NAME,
properties=settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_META,
data=data,
is_public=True,
disk_format='qcow2',
container_format='bare')
path_to_tests = 'fuel_health.tests.tests_platform.test_sahara.'
test_names = ['VanillaTwoClusterTest.test_vanilla_two_cluster']
for test_name in test_names:
LOGGER.debug('Run platform test {0} for Sahara'.format(test_name))
self.fuel_web.run_single_ostf_test(cluster_id=cluster_id,
test_sets=['tests_platform'],
test_name=path_to_tests +
test_name,
timeout=60 * 200)
self.env.make_snapshot("deploy_sahara_ha_one_controller_tun")
def deploy_heat_ha(self):
"""Deploy Heat cluster in HA mode
Scenario:
1. Create cluster
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify heat services
6. Run OSTF
7. Register heat image
8. Run OSTF platform tests
Snapshot: deploy_heat_ha
"""
self.env.revert_snapshot("ready_with_5_slaves")
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_HEAT_IMAGE,
settings.SERVTEST_HEAT_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image, "Image verification failed")
data = {
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready(
'slave-01', smiles_count=13, networks_count=1, timeout=300)
for slave in ["slave-01", "slave-02", "slave-03"]:
checkers.verify_service(
self.env.get_ssh_to_remote_by_name(slave),
service_name='heat-api', count=3)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
common_func = Common(cluster_vip,
data['user'],
data['password'],
data['tenant'])
LOGGER.debug('Import Heat image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_HEAT_IMAGE,
settings.SERVTEST_HEAT_IMAGE_NAME,
settings.SERVTEST_HEAT_IMAGE_META)
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_rollback']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha")
def deploy_sahara_ha_gre(self):
"""Deploy cluster in HA mode with Sahara and Neutron GRE
Scenario:
1. Create cluster. Set install Sahara option
2. Add 3 node with controller role
3. Add 1 node with compute role
4. Deploy the cluster
5. Verify Sahara services
6. Run OSTF
7. Register Sahara image
8. Run OSTF platform Sahara test only
Snapshot: deploy_sahara_ha_gre
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_SAHARA_IMAGE,
settings.SERVTEST_SAHARA_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
self.env.revert_snapshot("ready_with_5_slaves")
LOGGER.debug('Create cluster for sahara tests')
data = {
'sahara': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'saharaHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings=data
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
cluster_vip, data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=13, networks_count=2, timeout=300)
for slave in ["slave-01", "slave-02", "slave-03"]:
checkers.verify_service(
self.env.get_ssh_to_remote_by_name(slave),
service_name='sahara-all')
common_func = Common(cluster_vip, data['user'], data['password'],
data['tenant'])
test_classes = ['fuel_health.tests.sanity.test_sanity_sahara.'
'SanitySaharaTests.test_sanity_sahara']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes
)
LOGGER.debug('Import image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAHARA_IMAGE,
settings.SERVTEST_SAHARA_IMAGE_NAME,
settings.SERVTEST_SAHARA_IMAGE_META)
common_func.goodbye_security()
LOGGER.debug('Run OSTF Sahara platform test')
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=('fuel_health.tests.platform_tests.'
'test_sahara.PlatformSaharaTests.'
'test_platform_sahara'), timeout=60 * 200)
self.env.make_snapshot("deploy_sahara_ha_gre")
def deploy_murano_simple(self):
"""Deploy cluster in simple mode with Murano
Scenario:
1. Create cluster. Set install Murano option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify murano services
6. Run OSTF
7. Register murano image
8. Run OSTF platform tests
Snapshot: deploy_murano_simple
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(settings.SERVTEST_MURANO_SERVER_URL,
settings.SERVTEST_MURANO_IMAGE,
settings.SERVTEST_MURANO_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image, "Image verification failed")
data = {
'murano': True,
"net_provider": 'neutron',
"net_segment_type": 'gre',
'tenant': 'muranoSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
settings=data)
self.fuel_web.update_nodes(cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready('slave-01',
smiles_count=5,
networks_count=1,
timeout=300)
checkers.verify_service(self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='murano-api')
controller_ip = self.fuel_web.get_nailgun_node_by_name(
'slave-01')['ip']
common_func = Common(controller_ip, data['user'], data['password'],
data['tenant'])
LOGGER.debug('Run sanity and functional oSTF tests')
test_classes = [
'fuel_health.tests.sanity.test_sanity_murano.'
'MuranoSanityTests.test_create_and_delete_service'
]
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes)
LOGGER.debug('Import image')
common_func.image_import(settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_MURANO_IMAGE,
settings.SERVTEST_MURANO_IMAGE_NAME,
settings.SERVTEST_MURANO_IMAGE_META)
LOGGER.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests'
'.test_platform_murano_linux.'
'MuranoDeployLinuxServicesTests')
tests_names = [
'test_deploy_telnet_service', 'test_deploy_apache_service'
]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main, test_name))
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes,
test_sets=['platform_tests'])
self.env.make_snapshot("deploy_murano_simple")
def deploy_sahara_ha_one_controller_tun(self):
"""Deploy cluster in ha mode with 1 controller Sahara and Neutron VXLAN
Scenario:
1. Create a Fuel cluster. Set the option for Sahara installation
2. Add 1 node with "controller" role
3. Add 1 node with "compute" role
4. Deploy the Fuel cluster
5. Verify Sahara service on controller
6. Run all sanity and smoke tests
7. Register Vanilla2 image for Sahara
8. Run platform Vanilla2 test for Sahara
Duration 65m
Snapshot: deploy_sahara_ha_one_controller_tun
"""
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Create Fuel cluster for Sahara tests')
data = {
'sahara': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'saharaSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=5)
LOGGER.debug('Verify Sahara service on controller')
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='sahara-api')
checkers.verify_service(
remote,
service_name='sahara-engine')
LOGGER.debug('Check MD5 sum of Vanilla2 image')
check_image = checkers.check_image(
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
LOGGER.debug('Run all sanity and smoke tests')
path_to_tests = 'fuel_health.tests.sanity.test_sanity_sahara.'
test_names = ['VanillaTwoTemplatesTest.test_vanilla_two_templates',
'HDPTwoTemplatesTest.test_hdp_two_templates']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=[path_to_tests + test_name
for test_name in test_names]
)
LOGGER.debug('Import Vanilla2 image for Sahara')
with open('{0}/{1}'.format(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE)) as data:
os_conn.create_image(
name=settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_NAME,
properties=settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_META,
data=data,
is_public=True,
disk_format='qcow2',
container_format='bare')
path_to_tests = 'fuel_health.tests.tests_platform.test_sahara.'
test_names = ['VanillaTwoClusterTest.test_vanilla_two_cluster']
for test_name in test_names:
LOGGER.debug('Run platform test {0} for Sahara'.format(test_name))
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=path_to_tests + test_name, timeout=60 * 200)
self.env.make_snapshot("deploy_sahara_ha_one_controller_tun")
def deploy_savanna_simple(self):
"""Deploy cluster in simple mode with Savanna
Scenario:
1. Create cluster. Set install Sahara option
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Deploy the cluster
5. Verify sahara services
6. Run OSTF
7. Register sahara image
8. Run OSTF platform sahara tests only
Snapshot: deploy_sahara_simple
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_SAVANNA_SERVER_URL,
settings.SERVTEST_SAVANNA_IMAGE,
settings.SERVTEST_SAVANNA_IMAGE_MD5, settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Create cluster for sahara tests')
data = {
'sahara': True,
"net_provider": 'neutron',
"net_segment_type": 'gre',
'tenant': 'saharaSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
settings=data)
self.fuel_web.update_nodes(cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready('slave-01',
smiles_count=5,
networks_count=1,
timeout=300)
checkers.verify_service(self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='sahara-api')
controller_ip = self.fuel_web.get_nailgun_node_by_name(
'slave-01')['ip']
common_func = Common(controller_ip, data['user'], data['password'],
data['tenant'])
failed_test_name = ['Create volume and attach it to instance']
test_classes = [
'fuel_health.tests.sanity.test_sanity_savanna.'
'SanitySavannaTests.test_sanity_savanna'
]
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes)
LOGGER.debug('Import image')
common_func.image_import(settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAVANNA_IMAGE,
settings.SERVTEST_SAVANNA_IMAGE_NAME,
settings.SERVTEST_SAVANNA_IMAGE_META)
common_func.goodbye_security()
LOGGER.debug('Run OSTF savanna platform tests')
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id,
test_sets=['platform_tests'],
test_name=('fuel_health.tests.platform_tests.'
'test_platform_savanna.PlatformSavannaTests.'
'test_platform_savanna'),
should_fail=1,
timeout=60 * 200,
failed_test_name=failed_test_name)
self.env.make_snapshot("deploy_sahara_simple")
def deploy_heat_simple_nova(self):
"""Deploy Heat cluster in simple mode with Nova Network
Scenario:
1. Create cluster
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify heat services
6. Run OSTF
7. Register heat image
8. Run OSTF platform tests
Snapshot: deploy_heat_simple_nova
"""
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_HEAT_IMAGE,
settings.SERVTEST_HEAT_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image, "Image verification failed")
data = {
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
controller = self.fuel_web.get_nailgun_node_by_name('slave-01')
os_conn = os_actions.OpenStackActions(
controller['ip'], data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=6, networks_count=1, timeout=300)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='heat-api', count=3)
common_func = Common(controller['ip'],
data['user'],
data['password'],
data['tenant'])
LOGGER.debug('Import Heat image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_HEAT_IMAGE,
settings.SERVTEST_HEAT_IMAGE_NAME,
settings.SERVTEST_HEAT_IMAGE_META)
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_autoscaling',
'test_rollback']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_simple_nova")
def deploy_heat_ha_one_controller_neutron(self):
"""Deploy Heat cluster in HA mode with Neutron VXLAN
Scenario:
1. Create cluster
2. Add 1 node with controller role and mongo
3. Add 1 nodes with compute role
4. Set install Ceilometer option
5. Deploy the cluster
6. Verify Heat, Ceilometer services
7. Run OSTF platform tests
Duration 40m
Snapshot: deploy_heat_ha_one_controller_neutron
"""
self.env.revert_snapshot("ready_with_3_slaves")
data = {
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=5)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(_ip, service_name='heat-api', count=5)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(_ip,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
logger.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_advanced_actions',
'test_autoscaling',
'test_rollback',
'test_update',
'test_wait_condition']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha_one_controller_neutron")
def deploy_sahara_ha_one_controller_gre(self):
"""Deploy cluster in ha mode with 1 controller Sahara and Neutron GRE
Scenario:
1. Create a Fuel cluster. Set the option for Sahara installation
2. Add 1 node with "controller" role
3. Add 1 node with "compute" role
4. Deploy the Fuel cluster
5. Verify Sahara service on controller
6. Run all sanity and smoke tests
7. Register Vanilla2 image for Sahara
8. Run platform Vanilla2 test for Sahara
Duration 65m
Snapshot: deploy_sahara_ha_one_controller_gre
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
LOGGER.debug('Check MD5 sum of Vanilla2 image')
check_image = checkers.check_image(
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Create Fuel cluster for Sahara tests')
data = {
'sahara': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'saharaSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=5, networks_count=2, timeout=300)
LOGGER.debug('Verify Sahara service on controller')
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='sahara-all')
LOGGER.debug('Run all sanity and smoke tests')
path_to_tests = 'fuel_health.tests.sanity.test_sanity_sahara.'
test_names = ['VanillaTwoTemplatesTest.test_vanilla_two_templates',
'HDPTwoTemplatesTest.test_hdp_two_templates']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=[path_to_tests + test_name
for test_name in test_names]
)
LOGGER.debug('Import Vanilla2 image for Sahara')
common_func = Common(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_NAME,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_META)
path_to_tests = 'fuel_health.tests.platform_tests.test_sahara.'
test_names = ['VanillaTwoClusterTest.test_vanilla_two_cluster']
for test_name in test_names:
LOGGER.debug('Run platform test {0} for Sahara'.format(test_name))
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=path_to_tests + test_name, timeout=60 * 200)
self.env.make_snapshot("deploy_sahara_ha_one_controller_gre")
def deploy_heat_ha(self):
"""Deploy Heat cluster in HA mode
Scenario:
1. Create cluster
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify heat services
6. Run OSTF
7. Register heat image
8. Run OSTF platform tests
Snapshot: deploy_heat_ha
"""
self.env.revert_snapshot("ready_with_5_slaves")
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_HEAT_IMAGE,
settings.SERVTEST_HEAT_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image, "Image verification failed")
data = {
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
cluster_vip, data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=13, networks_count=2, timeout=300)
for slave in ["slave-01", "slave-02", "slave-03"]:
checkers.verify_service(
self.env.get_ssh_to_remote_by_name(slave),
service_name='heat-api', count=3)
common_func = Common(cluster_vip,
data['user'],
data['password'],
data['tenant'])
LOGGER.debug('Import Heat image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_HEAT_IMAGE,
settings.SERVTEST_HEAT_IMAGE_NAME,
settings.SERVTEST_HEAT_IMAGE_META)
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_rollback']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha")
def deploy_savanna_simple(self):
"""Deploy cluster in simple mode with Savanna
Scenario:
1. Create cluster. Set install Sahara option
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Deploy the cluster
5. Verify sahara services
6. Run OSTF
7. Register sahara image
8. Run OSTF platform sahara tests only
Snapshot: deploy_sahara_simple
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_SAVANNA_SERVER_URL,
settings.SERVTEST_SAVANNA_IMAGE,
settings.SERVTEST_SAVANNA_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Create cluster for sahara tests')
data = {
'sahara': True,
"net_provider": 'neutron',
"net_segment_type": 'gre',
'tenant': 'saharaSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings=data
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready(
'slave-01', smiles_count=5, networks_count=1, timeout=300)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='sahara-api')
controller_ip = self.fuel_web.get_nailgun_node_by_name(
'slave-01')['ip']
common_func = Common(controller_ip,
data['user'],
data['password'],
data['tenant'])
failed_test_name = ['Create volume and attach it to instance']
test_classes = ['fuel_health.tests.sanity.test_sanity_savanna.'
'SanitySavannaTests.test_sanity_savanna']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes
)
LOGGER.debug('Import image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAVANNA_IMAGE,
settings.SERVTEST_SAVANNA_IMAGE_NAME,
settings.SERVTEST_SAVANNA_IMAGE_META)
common_func.goodbye_security()
LOGGER.debug('Run OSTF savanna platform tests')
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=('fuel_health.tests.platform_tests.'
'test_platform_savanna.PlatformSavannaTests.'
'test_platform_savanna'), should_fail=1,
timeout=60 * 200, failed_test_name=failed_test_name)
self.env.make_snapshot("deploy_sahara_simple")
def deploy_heat_simple_neutron(self):
"""Deploy Heat cluster in simple mode with Neutron GRE
Scenario:
1. Create cluster
2. Add 1 node with controller role and mongo
3. Add 1 nodes with compute role
4. Set install Ceilometer option
5. Deploy the cluster
6. Verify Heat, Ceilometer services
7. Run OSTF platform tests
Snapshot: deploy_heat_simple_neutron
"""
self.env.revert_snapshot("ready_with_3_slaves")
data = {
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
controller = self.fuel_web.get_nailgun_node_by_name('slave-01')
os_conn = os_actions.OpenStackActions(
controller['ip'], data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=5, networks_count=2, timeout=300)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='heat-api', count=3)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_autoscaling',
'test_rollback',
'test_update']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_simple_neutron")
def deploy_ceilometer_simple_with_mongo(self):
"""Deploy cluster in simple mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with cinder role
5. Add 1 node with mongo role
6. Deploy the cluster
7. Verify ceilometer api is running
8. Run ostf
Snapshot: deploy_ceilometer_simple_with_mongo
"""
self.env.revert_snapshot("ready_with_5_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings={
'ceilometer': True,
'tenant': 'ceilometerSimple',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder'],
'slave-04': ['mongo']
}
)
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
disk_mb = 0
for node in nailgun_nodes:
if node.get('pending_roles') == ['mongo']:
disk_mb = self.fuel_web.get_node_disk_size(node.get('id'),
"vda")
LOGGER.debug('disk size is {0}'.format(disk_mb))
mongo_disk_mb = 11116
os_disk_mb = disk_mb - mongo_disk_mb
mongo_disk_gb = ("{0}G".format(round(mongo_disk_mb / 1024, 1)))
disk_part = {
"vda": {
"os": os_disk_mb,
"mongo": mongo_disk_mb
}
}
for node in nailgun_nodes:
if node.get('pending_roles') == ['mongo']:
self.fuel_web.update_node_disk(node.get('id'), disk_part)
self.fuel_web.deploy_cluster_wait(cluster_id)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
partitions = checkers.get_mongo_partitions(
self.env.get_ssh_to_remote_by_name("slave-04"), "vda5")
assert_equal(partitions[0].rstrip(), mongo_disk_gb,
'Mongo size {0} before deployment is not equal'
' to size after {1}'.format(mongo_disk_gb, partitions))
# run ostf
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke', 'sanity',
'platform_tests'],
should_fail=1, timeout=5300)
self.env.make_snapshot("deploy_ceilometer_simple_with_mongo")
def deploy_heat_ha(self):
"""Deploy Heat cluster in HA mode
Scenario:
1. Create cluster
2. Add 3 node with controller role and mongo
3. Add 1 nodes with compute role
4. Set Ceilometer install option
5. Deploy the cluster
6. Verify Heat and Ceilometer services
7. Run OSTF platform tests
Duration 70m
Snapshot: deploy_heat_ha
"""
self.env.revert_snapshot("ready_with_5_slaves")
data = {
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'heatHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller', 'mongo'],
'slave-02': ['controller', 'mongo'],
'slave-03': ['controller', 'mongo'],
'slave-04': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(cluster_vip, data['user'],
data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=13)
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote,
service_name='heat-api',
count=3)
checkers.verify_service(remote,
service_name='ceilometer-api',
ignore_count_of_proccesses=True)
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform.'
'test_heat.'
'HeatSmokeTests')
tests_names = [
'test_actions', 'test_advanced_actions', 'test_autoscaling',
'test_rollback', 'test_update'
]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main, test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(cluster_id=cluster_id,
test_sets=['tests_platform'],
test_name=test_name,
timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha")
def deploy_sahara_ha_gre(self):
"""Deploy cluster in HA mode with Sahara and Neutron GRE
Scenario:
1. Create a Fuel cluster. Set the option for Sahara installation
2. Add 3 node with "controller" role
3. Add 1 node with "compute" role
4. Deploy the Fuel cluster
5. Verify Sahara service on all controllers
6. Run all sanity and smoke tests
7. Register Vanilla2 image for Sahara
8. Run platform Vanilla2 test for Sahara
Duration 130m
Snapshot: deploy_sahara_ha_gre
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
LOGGER.debug('Check MD5 sum of Vanilla2 image')
check_image = checkers.check_image(
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
self.env.revert_snapshot("ready_with_5_slaves")
LOGGER.debug('Create Fuel cluster for Sahara tests')
data = {
'sahara': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'saharaHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
cluster_vip, data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=13, networks_count=2, timeout=300)
LOGGER.debug('Verify Sahara service on all controllers')
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='sahara-all')
LOGGER.debug('Run all sanity and smoke tests')
path_to_tests = 'fuel_health.tests.sanity.test_sanity_sahara.'
test_names = ['VanillaTwoTemplatesTest.test_vanilla_two_templates',
'HDPTwoTemplatesTest.test_hdp_two_templates']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=[path_to_tests + test_name
for test_name in test_names]
)
LOGGER.debug('Import Vanilla2 image for Sahara')
common_func = Common(cluster_vip,
data['user'], data['password'], data['tenant'])
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_NAME,
settings.SERVTEST_SAHARA_VANILLA_2_IMAGE_META)
path_to_tests = 'fuel_health.tests.tests_platform.test_sahara.'
test_names = ['VanillaTwoClusterTest.test_vanilla_two_cluster']
for test_name in test_names:
LOGGER.debug('Run platform test {0} for Sahara'.format(test_name))
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=path_to_tests + test_name, timeout=60 * 200)
self.env.make_snapshot("deploy_sahara_ha_gre")
def deploy_murano_ha_with_tun(self):
"""Deploy cluster in ha mode with Murano and Neutron VXLAN
Scenario:
1. Create cluster. Set install Murano option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify Murano services
6. Run OSTF
7. Run OSTF Murano platform tests
Duration 100m
Snapshot: deploy_murano_ha_with_tun
"""
self.env.revert_snapshot("ready_with_5_slaves")
data = {
'murano': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'muranoHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
cluster_vip, data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=13)
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='murano-api')
LOGGER.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_single_ostf_test(
cluster_id=self.fuel_web.get_last_created_cluster(),
test_sets=['sanity'],
test_name=('fuel_health.tests.sanity.test_sanity_murano.'
'MuranoSanityTests.test_create_and_delete_service')
)
LOGGER.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform'
'.test_murano_linux.MuranoDeployLinuxServicesTests')
tests_names = ['test_deploy_dummy_app', ]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=test_name, timeout=60 * 20)
self.env.make_snapshot("deploy_murano_ha_with_tun")
def deploy_murano_ha_one_controller_gre(self):
"""Deploy cluster in HA mode with Murano and Neutron GRE
Scenario:
1. Create cluster. Set install Murano option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify Murano services
6. Run OSTF
7. Run OSTF Murano platform tests
Duration 40m
Snapshot: deploy_murano_ha_one_controller_gre
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
self.env.revert_snapshot("ready_with_3_slaves")
data = {
'murano': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'muranoSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=5, networks_count=2, timeout=300)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='murano-api')
LOGGER.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_single_ostf_test(
cluster_id=self.fuel_web.get_last_created_cluster(),
test_sets=['sanity'],
test_name=('fuel_health.tests.sanity.test_sanity_murano.'
'MuranoSanityTests.test_create_and_delete_service')
)
LOGGER.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform'
'.test_murano_linux.MuranoDeployLinuxServicesTests')
tests_names = ['test_deploy_dummy_app', ]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=test_name, timeout=60 * 20)
self.env.make_snapshot("deploy_murano_ha_one_controller_gre")
def deploy_ceilometer_ha_one_controller_with_mongo(self):
"""Deploy cluster in HA mode with Ceilometer
Scenario:
1. Create cluster. Set install Ceilometer option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Add 1 node with cinder role
5. Add 1 node with mongo role
6. Deploy the cluster
7. Verify ceilometer api is running
8. Run OSTF
Duration 45m
Snapshot: deploy_ceilometer_ha_one_controller_with_mongo
"""
self.env.revert_snapshot("ready_with_3_slaves")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': 'tun',
'tenant': 'ceilometerSimple',
'user': '******',
'password': '******'
}
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute', 'cinder'],
'slave-03': ['mongo']
}
)
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
disk_mb = 0
for node in nailgun_nodes:
if node.get('pending_roles') == ['mongo']:
disk_mb = self.fuel_web.get_node_disk_size(node.get('id'),
"vda")
LOGGER.debug('disk size is {0}'.format(disk_mb))
mongo_disk_mb = 11116
os_disk_mb = disk_mb - mongo_disk_mb
mongo_disk_gb = ("{0}G".format(round(mongo_disk_mb / 1024, 1)))
disk_part = {
"vda": {
"os": os_disk_mb,
"mongo": mongo_disk_mb
}
}
for node in nailgun_nodes:
if node.get('pending_roles') == ['mongo']:
self.fuel_web.update_node_disk(node.get('id'), disk_part)
self.fuel_web.deploy_cluster_wait(cluster_id)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='ceilometer-api')
_ip = self.fuel_web.get_nailgun_node_by_name("slave-03")['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
partitions = checkers.get_mongo_partitions(remote, "vda5")
assert_equal(partitions[0].rstrip(), mongo_disk_gb,
'Mongo size {0} before deployment is not equal'
' to size after {1}'.format(mongo_disk_gb, partitions))
self.run_tests(cluster_id)
self.env.make_snapshot(
"deploy_ceilometer_ha_one_controller_with_mongo")
def deploy_heat_ha_one_controller_nova(self):
"""Deploy Heat cluster in ha mode with Nova Network
Scenario:
1. Create cluster
2. Add 1 node with controller role and mongo
3. Add 1 nodes with compute role
4. Set Ceilometer install option
4. Deploy the cluster
5. Verify Heat, Ceilometer services
6. Run OSTF platform tests
Duration 40m
Snapshot: deploy_heat_ha_one_controller_nova
"""
self.env.revert_snapshot("ready_with_3_slaves")
data = {
'ceilometer': True,
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=6, networks_count=1, timeout=300)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='heat-api', count=3)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(
self.env.d_env.get_ssh_to_remote(_ip),
service_name='ceilometer-api')
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_advanced_actions',
'test_autoscaling',
'test_rollback',
'test_update']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha_one_controller_nova")
def deploy_heat_ha(self):
"""Deploy Heat cluster in HA mode
Scenario:
1. Create cluster
2. Add 3 node with controller role and mongo
3. Add 1 nodes with compute role
4. Set Ceilometer install option
5. Deploy the cluster
6. Verify Heat and Ceilometer services
7. Run OSTF platform tests
Duration 70m
Snapshot: deploy_heat_ha
"""
self.env.revert_snapshot("ready_with_5_slaves")
data = {
'ceilometer': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'heatHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['controller', 'mongo'],
'slave-03': ['controller', 'mongo'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
cluster_vip, data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=13)
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(
remote,
service_name='heat-api', count=3)
checkers.verify_service(
remote,
service_name='ceilometer-api')
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_advanced_actions',
'test_autoscaling',
'test_rollback',
'test_update']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['tests_platform'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha")
def deploy_murano_ha_with_tun(self):
"""Deploy cluster in ha mode with Murano and Neutron VXLAN
Scenario:
1. Create cluster. Set install Murano option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify Murano services
6. Run OSTF
7. Run OSTF Murano platform tests
Duration 100m
Snapshot: deploy_murano_ha_with_tun
"""
self.env.revert_snapshot("ready_with_5_slaves")
data = {
'murano': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'muranoHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(cluster_vip, data['user'],
data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=13)
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
with self.env.d_env.get_ssh_to_remote(_ip) as remote:
checkers.verify_service(remote, service_name='murano-api')
LOGGER.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_single_ostf_test(
cluster_id=self.fuel_web.get_last_created_cluster(),
test_sets=['sanity'],
test_name=('fuel_health.tests.sanity.test_sanity_murano.'
'MuranoSanityTests.test_create_and_delete_service'))
LOGGER.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform'
'.test_murano_linux.MuranoDeployLinuxServicesTests')
tests_names = [
'test_deploy_dummy_app',
]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main, test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(cluster_id=cluster_id,
test_sets=['tests_platform'],
test_name=test_name,
timeout=60 * 20)
self.env.make_snapshot("deploy_murano_ha_with_tun")
def deploy_murano_simple(self):
"""Deploy cluster in simple mode with Murano
Scenario:
1. Create cluster. Set install Murano option
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify murano services
6. Run OSTF
7. Register murano image
8. Run OSTF platform tests
Snapshot: deploy_murano_simple
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
self.env.revert_snapshot("ready_with_3_slaves")
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_MURANO_SERVER_URL,
settings.SERVTEST_MURANO_IMAGE,
settings.SERVTEST_MURANO_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image, "Image verification failed")
data = {
'murano': True,
"net_provider": 'neutron',
"net_segment_type": 'gre',
'tenant': 'muranoSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready(
'slave-01', smiles_count=5, networks_count=1, timeout=300)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='murano-api')
controller_ip = self.fuel_web.get_nailgun_node_by_name(
'slave-01')['ip']
common_func = Common(controller_ip,
data['user'],
data['password'],
data['tenant'])
LOGGER.debug('Run sanity and functional oSTF tests')
test_classes = ['fuel_health.tests.sanity.test_sanity_murano.'
'MuranoSanityTests.test_create_and_delete_service']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes
)
LOGGER.debug('Import image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_MURANO_IMAGE,
settings.SERVTEST_MURANO_IMAGE_NAME,
settings.SERVTEST_MURANO_IMAGE_META)
LOGGER.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests'
'.test_platform_murano_linux.'
'MuranoDeployLinuxServicesTests')
tests_names = ['test_deploy_telnet_service',
'test_deploy_apache_service']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes, test_sets=['platform_tests'])
self.env.make_snapshot("deploy_murano_simple")
def deploy_sahara_ha_gre(self):
"""Deploy cluster in HA mode with Sahara and Neutron GRE
Scenario:
1. Create cluster. Set install Sahara option
2. Add 3 node with controller role
3. Add 1 node with compute role
4. Deploy the cluster
5. Verify Sahara services
6. Run OSTF
7. Register Sahara image
8. Run OSTF platform Sahara test only
Snapshot: deploy_sahara_ha_gre
"""
if settings.OPENSTACK_RELEASE == settings.OPENSTACK_RELEASE_REDHAT:
raise SkipTest()
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_SAVANNA_IMAGE,
settings.SERVTEST_SAVANNA_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image)
self.env.revert_snapshot("ready_with_5_slaves")
LOGGER.debug('Create cluster for sahara tests')
data = {
'sahara': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'saharaHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings=data
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.assert_cluster_ready(
'slave-01', smiles_count=13, networks_count=1, timeout=300)
for slave in ["slave-01", "slave-02", "slave-03"]:
checkers.verify_service(
self.env.get_ssh_to_remote_by_name(slave),
service_name='sahara-api')
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
common_func = Common(cluster_vip, data['user'], data['password'],
data['tenant'])
test_classes = ['fuel_health.tests.sanity.test_sanity_savanna.'
'SanitySavannaTests.test_sanity_savanna']
self.fuel_web.run_ostf(
cluster_id=self.fuel_web.get_last_created_cluster(),
tests_must_be_passed=test_classes
)
LOGGER.debug('Import image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_SAVANNA_IMAGE,
settings.SERVTEST_SAVANNA_IMAGE_NAME,
settings.SERVTEST_SAVANNA_IMAGE_META)
common_func.goodbye_security()
LOGGER.debug('Run OSTF Sahara platform test')
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=('fuel_health.tests.platform_tests.'
'test_platform_savanna.PlatformSavannaTests.'
'test_platform_savanna'), timeout=60 * 200)
self.env.make_snapshot("deploy_sahara_ha_gre")
def deploy_heat_ha_one_controller_nova(self):
"""Deploy Heat cluster in ha mode with Nova Network
Scenario:
1. Create cluster
2. Add 1 node with controller role and mongo
3. Add 1 nodes with compute role
4. Set Ceilometer install option
4. Deploy the cluster
5. Verify Heat, Ceilometer services
6. Run OSTF platform tests
Duration 40m
Snapshot: deploy_heat_ha_one_controller_nova
"""
self.env.revert_snapshot("ready_with_3_slaves")
data = {
'ceilometer': True,
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller', 'mongo'],
'slave-02': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id),
data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=6, networks_count=1, timeout=300)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='heat-api', count=3)
checkers.verify_service(
self.env.get_ssh_to_remote_by_name("slave-01"),
service_name='ceilometer-api')
LOGGER.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests.'
'test_heat.'
'HeatSmokeTests')
tests_names = ['test_actions',
'test_autoscaling',
'test_rollback',
'test_update']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=test_name, timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha_one_controller_nova")
def deploy_murano_ha_with_tun(self):
"""Deploy cluster in ha mode with Murano and Neutron VXLAN
Scenario:
1. Create cluster. Set install Murano option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify Murano services
6. Run OSTF
7. Run OSTF Murano platform tests
Duration 100m
Snapshot: deploy_murano_ha_with_tun
"""
self.env.revert_snapshot("ready_with_5_slaves")
data = {
'murano': True,
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'muranoHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data,
configure_ssl=False)
# TODO(freerunner): Need to configure SSL again when root cause for
# TODO(freerunner): https://bugs.launchpad.net/fuel/+bug/1590633
# TODO(freerunner): will be found and fixed
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
for slave in ["slave-01", "slave-02", "slave-03"]:
_ip = self.fuel_web.get_nailgun_node_by_name(slave)['ip']
checkers.verify_service(_ip, service_name='murano-api')
logger.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_ostf(cluster_id=cluster_id, test_sets=['sanity'])
logger.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform'
'.test_murano_linux.MuranoDeployLinuxServicesTests')
tests_names = ['test_deploy_dummy_app_with_glare']
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main, test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(cluster_id=cluster_id,
test_sets=['tests_platform'],
test_name=test_name,
timeout=60 * 20)
self.env.make_snapshot("deploy_murano_ha_with_tun")
def deploy_murano_ha_with_gre(self):
"""Deploy cluster in ha mode with Murano and Neutron GRE
Scenario:
1. Create cluster. Set install Murano option
2. Add 3 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify Murano services
6. Run OSTF
7. Register Murano image
8. Run OSTF Murano platform tests
Duration 100m
Snapshot: deploy_murano_ha_with_gre
"""
self.env.revert_snapshot("ready_with_5_slaves")
LOGGER.debug('Check MD5 of image')
check_image = checkers.check_image(
settings.SERVTEST_MURANO_IMAGE,
settings.SERVTEST_MURANO_IMAGE_MD5,
settings.SERVTEST_LOCAL_PATH)
asserts.assert_true(check_image, "Image verification failed")
data = {
'murano': True,
'net_provider': 'neutron',
'net_segment_type': 'gre',
'tenant': 'muranoHA',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute']
}
)
self.fuel_web.deploy_cluster_wait(cluster_id)
cluster_vip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
cluster_vip, data['user'], data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(
os_conn, smiles_count=13, networks_count=2, timeout=300)
for slave in ["slave-01", "slave-02", "slave-03"]:
checkers.verify_service(
self.env.get_ssh_to_remote_by_name(slave),
service_name='murano-api')
common_func = Common(cluster_vip, data['user'], data['password'],
data['tenant'])
LOGGER.debug('Run sanity and functional Murano OSTF tests')
self.fuel_web.run_single_ostf_test(
cluster_id=self.fuel_web.get_last_created_cluster(),
test_sets=['sanity'],
test_name=('fuel_health.tests.sanity.test_sanity_murano.'
'MuranoSanityTests.test_create_and_delete_service')
)
LOGGER.debug('Import Murano image')
common_func.image_import(
settings.SERVTEST_LOCAL_PATH,
settings.SERVTEST_MURANO_IMAGE,
settings.SERVTEST_MURANO_IMAGE_NAME,
settings.SERVTEST_MURANO_IMAGE_META)
LOGGER.debug('Boot instance with Murano image')
image_name = settings.SERVTEST_MURANO_IMAGE_NAME
srv = common_func.create_instance(flavor_name='test_murano_flavor',
ram=2048, vcpus=1, disk=20,
server_name='murano_instance',
image_name=image_name,
neutron_network=True)
wait(lambda: common_func.get_instance_detail(srv).status == 'ACTIVE',
timeout=60 * 60)
common_func.delete_instance(srv)
LOGGER.debug('Run OSTF platform tests')
test_class_main = ('fuel_health.tests.platform_tests'
'.test_murano_linux.MuranoDeployLinuxServicesTests')
tests_names = ['test_deploy_apache_service', ]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main,
test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(
cluster_id=cluster_id, test_sets=['platform_tests'],
test_name=test_name, timeout=60 * 36)
self.env.make_snapshot("deploy_murano_ha_with_gre")
def deploy_heat_ha_one_controller_neutron(self):
"""Deploy Heat cluster in HA mode with Neutron VXLAN
Scenario:
1. Create cluster
2. Add 1 node with controller role
3. Add 1 nodes with compute role
4. Deploy the cluster
5. Verify Heat services
6. Run OSTF platform tests
Duration 40m
Snapshot: deploy_heat_ha_one_controller_neutron
"""
self.env.revert_snapshot("ready_with_3_slaves")
data = {
'net_provider': 'neutron',
'net_segment_type': settings.NEUTRON_SEGMENT['tun'],
'tenant': 'heatSimple',
'user': '******',
'password': '******'
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings=data)
self.fuel_web.update_nodes(cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute']
})
self.fuel_web.deploy_cluster_wait(cluster_id)
os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id), data['user'],
data['password'], data['tenant'])
self.fuel_web.assert_cluster_ready(os_conn, smiles_count=5)
_ip = self.fuel_web.get_nailgun_node_by_name("slave-01")['ip']
checkers.verify_service(_ip, service_name='heat-api', count=5)
logger.debug('Run Heat OSTF platform tests')
test_class_main = ('fuel_health.tests.tests_platform.'
'test_heat.'
'HeatSmokeTests')
tests_names = [
'test_actions', 'test_advanced_actions', 'test_rollback',
'test_update', 'test_wait_condition'
]
test_classes = []
for test_name in tests_names:
test_classes.append('{0}.{1}'.format(test_class_main, test_name))
for test_name in test_classes:
self.fuel_web.run_single_ostf_test(cluster_id=cluster_id,
test_sets=['tests_platform'],
test_name=test_name,
timeout=60 * 60)
self.env.make_snapshot("deploy_heat_ha_one_controller_neutron")
