def _setup_lb_network_and_servers(cmgr, x_name, **kwargs):
num_servers = kwargs.pop('num_servers', 2)
username = kwargs.pop('username', 'cirros')
password = kwargs.pop('password', 'cubswin:)')
image_id = kwargs.pop('image_id', None)
image_name = kwargs.pop('image_name', None)
flavor_id = kwargs.pop('flavor_id', 1)
extra_timeout = kwargs.pop('server_extra_wait_time', 1)
my_name = data_utils.rand_name(x_name)
cidr = kwargs.pop('cidr', '10.199.88.0/24')
port = kwargs.pop('port', 80)
public_network_id = kwargs.pop('public_network_id', None)
# NSX-v plugin need to use exclusive router for its lbaas env
# Overwrite it if your env requiring a different type
router_type = kwargs.pop('router_type', 'exclusive')
router, network, subnet = create_networks(cmgr, my_name, cidr,
router_type=router_type,
**kwargs)
sg = NET.create_security_group_loginable(cmgr, my_name, http=True)
# ssh keypair
keypair = make_ssh_keypair(cmgr, my_name)
kp_filename = keypair_to_tempfile_json(keypair)
servers = {}
for sid in range(1, (num_servers + 1)):
server_name = "%s-%d" % (my_name, sid)
server = NET.create_server_on_network(
cmgr, network['id'], security_group_name_or_id=sg['id'],
key_name=keypair['name'], server_name=server_name,
image_id=image_id, image_name=image_name,
flavor_id=flavor_id, wait_on_boot=False)
servers[server['id']] = dict(server=server, fip=None)
# servers need in status=ACTIVE before assign floatingip to them
# vm1 should be active by now
for server_id in servers.keys():
waiters.wait_for_server_status(
cmgr.manager.servers_client, server_id, 'ACTIVE',
extra_timeout=extra_timeout)
for server_id, server in servers.items():
server['fip'] = NET.create_floatingip_for_server(cmgr, server_id,
public_network_id)
server['server'] = cmgr.nova('server-show', server_id)
img_id = server['server']['image']['id']
img_name = cmgr.nova('image-show', img_id).get('name', '')
server['image_name'] = img_name
lb_env = dict(
name=my_name, username=username, password=password,
keypair=keypair, kp_filename=kp_filename,
security_group=sg,
router=router, port=port, network=network, subnet=subnet,
servers=servers)
return lb_env
def setup_mtz_simple(cmgr, x_name, **kwargs):
x_name = x_name or data_utils.rand_name('mtz-i')
wait4server_active = kwargs.pop('wait4servers', True)
tenant_cmgr = kwargs.pop('for_tenant', None)
if tenant_cmgr:
# in this condition, cmgr must have admin privilege
tenant_id = tenant_cmgr.manager.credentials.tenant_id
else:
tenant_cmgr = cmgr
tenant_id = kwargs.pop('tenant_id', None)
if tenant_id:
msg = "tenant_id not supported, use for_tenant=tenant_cmgr"
raise exceptions.NotImplementedError(msg)
router_type = kwargs.pop('router_type', 'shared')
scope_id_list = kwargs.pop('scope_id_list', [])
mtz_ip = netaddr.IPNetwork(kwargs.pop('cidr', '10.199.1.0/24'))
mask_bits = kwargs.pop('mask_bits', (mtz_ip.prefixlen + 3))
cidr_list = [x for x in mtz_ip.subnet(mask_bits)]
net_list = []
for ix, scope_id in enumerate(scope_id_list):
subnet_cidr = str(cidr_list[ix])
name = x_name + ("-%d" % (ix + 1))
network_subnet = create_mtz_networks(cmgr, scope_id, subnet_cidr,
name=name, tenant_id=tenant_id,
**kwargs)
net_list.append(network_subnet)
# server_create does not accept tenant_id, always use tenant_cmgr
router = NET.create_router_and_add_interfaces(tenant_cmgr,
x_name + "-router",
net_list,
router_type=router_type,
tenant_id=tenant_id)
sg = NET.create_security_group_loginable(tenant_cmgr, x_name,
tenant_id=tenant_id)
security_group_id = sg['id']
net_id_servers = {}
for ix, (network, subnet) in enumerate(net_list):
net_id = network['id']
vm = NET.create_server_on_network(
tenant_cmgr, net_id,
security_group_name_or_id=security_group_id,
server_name=network['name'])
net_id_servers[net_id] = dict(server=vm,
network=network, subnet=subnet)
if wait4server_active:
try:
wait_for_servers_active(cmgr, net_id_servers)
except Exception:
# if servers failed to be ACTIVE, we want to examine them
pass
return (router, net_id_servers, sg)
demo = osn.get_mcli("demo", password="******")
pub = demo.qsvc("net-show public")
mynet = demo.qsvc("net-show private")
fip_list = []
for ix in range(6):
fip = demo.qsvc("floatingip-create", pub["id"])
fip_list.append(fip)
from operator import itemgetter
fip2_list = sorted(fip_list, key=itemgetter("floating_ip_address"), reverse=True)
demo_sg = NETS.create_security_group_loginable(demo, "demo_sg_login")
demo_img = demo.nova("image-list", name=u"cirros-0.3.3-x86_64-disk")[0]
server_list = []
for ix in range(6):
sv_name = "demo-sv-%d" % ix
server = NETS.create_server_on_network(
demo, mynet["id"], sv_name, image_id=demo_img["id"], security_group_name_or_id=demo_sg["id"], wait_on_boot=False
)
server_list.append(server)
# waitfor all servers become ACTIVE
fip3 = {}
for ix in range(6):
fip = NETS.associate_floatingip_to_server(demo, fip_list[ix], server_list[ix])
fip3[fip.get("floating_ip_address")] = fip_list
def add_server_to_lb_network(cmgr, on_network_id, security_group_name_or_id,
sid_range, keypair_name=None,
username='******', password='******',
flavor_id=1, image_id=None, image_name=None,
public_network_id=None, extra_timeout=10,
build_timeout=900, build_interval=5.0,
halt=False):
if halt:
import pdb;
pdb.set_trace()
lb_network = cmgr.qsvc('net-show', on_network_id)
lb_network_name = lb_network.get('name', None)
sg = cmgr.qsvc('security-group-show', security_group_name_or_id)
if keypair_name is None:
# ssh keypair
keypair = make_ssh_keypair(cmgr, lb_network_name)
keypair_name = keypair['name']
else:
keypair = None
servers = {}
for sid in sid_range:
server_name = "%s-%s" % (lb_network_name, sid)
server = NET.create_server_on_network(
cmgr, on_network_id, security_group_name_or_id=sg['id'],
key_name=keypair_name, server_name=server_name,
image_id=image_id, image_name=image_name,
flavor_id=flavor_id, wait_on_boot=False)
servers[server['id']] = dict(server=server, fip=None)
# servers need in status=ACTIVE before assign floatingip to them
# vm1 should be active by now
for server_id in servers.keys():
waiters.wait_for_server_status(
cmgr.manager.servers_client, server_id, 'ACTIVE',
extra_timeout=extra_timeout)
for server_id, server in servers.items():
server['fip'] = NET.create_floatingip_for_server(cmgr, server_id,
public_network_id)
server['server'] = cmgr.nova('server-show', server_id)
img_id = server['server']['image']['id']
img_name = cmgr.nova('image-show', img_id).get('name', '')
server['image_name'] = img_name
# wait for servers having their floating-ip (CH+newton takes long time)
timeout = extra_timeout + build_timeout
t0 = time.time()
for server_id, server in servers.items():
while True:
elapse_time = time.time() - t0
sv = cmgr.nova('server-show', server_id)
if get_server_ip_address(sv, 'floating', lb_network_name):
msg = ("Take %d seconds to assign floating-ip to server[%s]"
% (int(elapse_time), sv.get('name')))
U.log_msg(msg, 'OS-LBaaS')
break
if elapse_time > timeout:
raise Exception("Server did not get its floating-ip.")
time.sleep(build_interval)
lb_env = dict(
username=username, password=password,
keypair_name=keypair_name, keypair=keypair,
security_group=sg, servers=servers)
return lb_env
