def remove_env(admin_node_ip, env_name, dont_wait_for_nodes=True):
LOG.info('Removing cluster with name:{0}'.format(env_name))
client = NailgunClient(admin_node_ip)
cluster_id = client.get_cluster_id(env_name)
all_nodes = []
if cluster_id:
cluster_nodes = client.list_cluster_nodes(cluster_id)
if len(cluster_nodes) > 0:
all_nodes = client.list_nodes()
client.delete_cluster(cluster_id)
else:
LOG.info('Looks like cluster has not been created before.Okay')
return "OK"
# wait for cluster to disappear
rerty_c = 120
for i in range(rerty_c):
cluster_id = client.get_cluster_id(env_name)
LOG.info('Wait for cluster to disappear...try %s /%s' % (i, rerty_c))
if cluster_id:
time.sleep(10)
else:
break
# fail if cluster is still around
if cluster_id:
return "Can't delete cluster"
# wait for removed nodes to come back online
if not dont_wait_for_nodes:
for i in range(90):
cur_nodes = client.list_nodes()
if len(cur_nodes) < len(all_nodes):
LOG.info('Wait for nodes to came back. Should be:{0} '
'Currently:{1} ...try {2}'.format(
len(all_nodes), len(cur_nodes), i))
time.sleep(10)
if len(client.list_nodes()) < len(all_nodes) and not dont_wait_for_nodes:
return "Timeout while waiting for removed nodes ({}) to come back up".format(
len(cluster_nodes))
return "OK"
def remove_env(admin_node_ip, env_name, dont_wait_for_nodes):
client = NailgunClient(admin_node_ip)
cluster_id = client.get_cluster_id(env_name)
need_to_wait_for_nodes = False
all_nodes = []
if cluster_id:
cluster_nodes = client.list_cluster_nodes(cluster_id)
if len(cluster_nodes) > 0:
need_to_wait_for_nodes = True
all_nodes = client.list_nodes()
client.delete_cluster(cluster_id)
else:
return "OK"
# wait for cluster to disappear
for i in range(60):
cluster_id = client.get_cluster_id(env_name)
if cluster_id:
time.sleep(10)
# fail if cluster is still around
if cluster_id:
return "Can't delete cluster"
# wait for removed nodes to come back online
if not dont_wait_for_nodes:
for i in range(90):
cur_nodes = client.list_nodes()
if len(cur_nodes) < len(all_nodes):
time.sleep(10)
if len(cur_nodes) < len(all_nodes) and not dont_wait_for_nodes:
return "Timeout while waiting for removed nodes ({}) to come back up".format(len(cluster_nodes))
return "OK"
def setup_env(admin_node_ip, env_name):
client = NailgunClient(admin_node_ip)
cluster_id = client.get_cluster_id(env_name)
release_id = client.get_release_id()
# delete previous cluster with the same name
if cluster_id:
client.delete_cluster(cluster_id)
for i in range(6):
cluster_id = client.get_cluster_id(env_name)
if cluster_id:
time.sleep(5)
if cluster_id:
return "Can't delete cluster"
# old cluster is gone so we're ok to create a new cluster
env = load_env(env_name)
data = env.data
if "net_provider" in env.settings:
data.update(
{
'net_provider': env.settings["net_provider"],
'net_segment_type': env.settings["net_segment_type"]
}
)
client.create_cluster(data=data)
time.sleep(5)
cluster_id = client.get_cluster_id(env_name)
# configure networks
network_conf = client.get_networks(cluster_id)
network_list = network_conf['networks']
for network in network_list:
# set vlan tags
if network["name"] in env.net_tag:
network['vlan_start'] = env.net_tag[network["name"]]
# set CIDR and related net stuff
if network["name"] in env.net_cidr:
network['cidr'] = env.net_cidr[network["name"]]
if network["name"] == "public":
if env.gateway:
network["gateway"] = env.gateway
else:
network["gateway"] = str(list(IPNetwork(network['cidr']))[1])
if network["name"] in env.net_ip_ranges:
network['ip_ranges'] = env.net_ip_ranges[network["name"]]
else:
if network["name"] == "public":
network['ip_ranges'] = get_range(network['cidr'], -1)
elif network["name"] == "floating":
network['ip_ranges'] = get_range(network['cidr'], 1)
else:
network['ip_ranges'] = get_range(network['cidr'], 0)
network['netmask'] = str(IPNetwork(network['cidr']).netmask)
network['network_size'] = len(list(IPNetwork((network['cidr']))))
network_conf['networks'] = network_list
# update neutron settings
if "net_provider" in env.settings:
if env.settings["net_provider"] == 'neutron':
# check if we need to set vlan tags
if env.settings["net_segment_type"] == 'vlan' and 'neutron_vlan_range' in env.settings:
network_conf['neutron_parameters']['L2']['phys_nets']['physnet2']['vlan_range'] = env.settings['neutron_vlan_range']
# check and update networks CIDR/netmask/size/etc
if 'net04' in env.net_cidr:
network_conf['neutron_parameters']['predefined_networks']['net04']['L3']['cidr'] = env.net_cidr['net04']
network_conf['neutron_parameters']['predefined_networks']['net04']['L3']['gateway'] = str(list(IPNetwork(env.net_cidr['net04']))[1])
if 'public' in env.net_cidr:
network_conf['neutron_parameters']['predefined_networks']['net04_ext']['L3']['cidr'] = env.net_cidr['public']
if env.gateway:
network_conf['neutron_parameters']['predefined_networks']['net04_ext']['L3']['gateway'] = env.gateway
else:
network_conf['neutron_parameters']['predefined_networks']['net04_ext']['L3']['gateway'] = str(list(IPNetwork(env.net_cidr['public']))[1])
if 'net04_ext' in env.net_ip_ranges:
network_conf['neutron_parameters']['predefined_networks']['net04_ext']['L3']['floating'] = env.net_ip_ranges["net04_ext"]
else:
network_conf['neutron_parameters']['predefined_networks']['net04_ext']['L3']['floating'] = get_range(env.net_cidr['public'], 2)
# push updated network to Fuel API
client.update_network(cluster_id, networks=network_conf, all_set=True)
# configure cluster attributes
attributes = client.get_cluster_attributes(cluster_id)
for option in env.settings:
section = False
if option in ('savanna', 'murano', 'ceilometer'):
section = 'additional_components'
if option in ('volumes_ceph', 'images_ceph', 'volumes_lvm'):
section = 'storage'
if option in ('libvirt_type', 'vlan_splinters'):
section = 'common'
if section:
attributes['editable'][section][option]['value'] = env.settings[option]
attributes['editable']['common']['debug']['value'] = True
client.update_cluster_attributes(cluster_id, attributes)
# get all nodes
for i in range(18):
all_nodes = client.list_nodes()
if len(all_nodes) < len(env.node_roles) + len(env.special_roles):
time.sleep(10)
# check if we have enough nodes for our test case
if len(all_nodes) < len(env.node_roles) + len(env.special_roles):
return "Not enough nodes"
nodes_data = []
node_local_id = 0
# go through unassigned nodes and update their pending_roles according to environment settings
for node in all_nodes:
if node['cluster'] == None and (node_local_id < len(env.node_roles) or node['mac'] in env.special_roles):
if node['mac'] in env.special_roles:
node_role = env.special_roles[node['mac']]
else:
node_role = env.node_roles[node_local_id]
node_local_id += 1
node_data = {
'cluster_id': cluster_id,
'id': node['id'],
'pending_addition': "true",
'pending_roles': node_role
}
nodes_data.append(node_data)
# add nodes to cluster
client.update_nodes(nodes_data)
# check if we assigned all nodes we wanted to
cluster_nodes = client.list_cluster_nodes(cluster_id)
if len(cluster_nodes) != len(env.node_roles) + len(env.special_roles):
return "Not enough nodes"
# move networks to appropriate nodes interfaces (according to environment settings)
for node in cluster_nodes:
node_id = node['id']
interfaces_dict = env.interfaces
interfaces = client.get_node_interfaces(node_id)
for interface in interfaces:
interface_name = interface['name']
interface['assigned_networks'] = []
for allowed_network in interface['allowed_networks']:
key_exists = interface_name in interfaces_dict
if key_exists and \
allowed_network['name'] \
in interfaces_dict[interface_name]:
interface['assigned_networks'].append(allowed_network)
client.put_node_interfaces(
[{'id': node_id, 'interfaces': interfaces}])
return "OK"
