381 lines
14 KiB
Python
381 lines
14 KiB
Python
from ipaddr import IPNetwork
|
|
import re
|
|
from fuel_test.helpers import load, write_config, is_not_essex
|
|
from fuel_test.root import root
|
|
from fuel_test.settings import INTERFACES, TEST_REPO
|
|
|
|
|
|
class Template(object):
|
|
def __init__(self, path):
|
|
super(Template, self).__init__()
|
|
self.value = load(path)
|
|
|
|
def p_(self, value):
|
|
"""
|
|
:rtype : str
|
|
"""
|
|
if isinstance(value, dict):
|
|
return self._hash(value)
|
|
if isinstance(value, list):
|
|
return self._list(value)
|
|
if isinstance(value, bool):
|
|
return self._bool(value)
|
|
if isinstance(value, int):
|
|
return str(value)
|
|
if isinstance(value, type(None)):
|
|
return 'undef'
|
|
return self._str(value)
|
|
|
|
def _hash(self, value):
|
|
return '{%s}' % ','.join(
|
|
["%s => %s" % (self.p_(k), self.p_(v)) for k, v in value.items()])
|
|
|
|
def _list(self, value):
|
|
return '[%s]' % ','.join(["%s" % self.p_(k) for k in value])
|
|
|
|
def _str(self, value):
|
|
ret = str(value)
|
|
if ret.startswith('$'):
|
|
return ret
|
|
return "'%s'" % ret
|
|
|
|
def _bool(self, value):
|
|
if not value: return 'false'
|
|
return 'true'
|
|
|
|
def _replace(self, template, **kwargs):
|
|
for key, value in kwargs.items():
|
|
template, count = re.subn(
|
|
'^(\$' + str(key) + ')\s*=.*', "\\1 = " + self.p_(value),
|
|
template,
|
|
flags=re.MULTILINE)
|
|
if count == 0:
|
|
raise Exception("Variable ${0:>s} not found".format(key))
|
|
return template
|
|
|
|
def replace(self, **kwargs):
|
|
self.value = self._replace(self.value, **kwargs)
|
|
return self
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
@classmethod
|
|
def stomp(cls):
|
|
return cls(root('deployment', 'puppet', 'mcollective', 'examples',
|
|
'site.pp'))
|
|
|
|
@classmethod
|
|
def minimal(cls):
|
|
return cls(root('deployment', 'puppet', 'openstack', 'examples',
|
|
'site_openstack_ha_minimal.pp'))
|
|
|
|
@classmethod
|
|
def compact(cls):
|
|
return cls(root('deployment', 'puppet', 'openstack', 'examples',
|
|
'site_openstack_ha_compact.pp'))
|
|
|
|
@classmethod
|
|
def full(cls):
|
|
return cls(root('deployment', 'puppet', 'openstack', 'examples',
|
|
'site_openstack_ha_full.pp'))
|
|
|
|
@classmethod
|
|
def nagios(cls):
|
|
return cls(root('deployment', 'puppet', 'nagios', 'examples',
|
|
'master.pp'))
|
|
|
|
|
|
class Manifest(object):
|
|
def mirror_type(self):
|
|
return 'custom'
|
|
|
|
def write_manifest(self, remote, manifest):
|
|
write_config(remote, '/etc/puppet/manifests/site.pp',
|
|
str(manifest))
|
|
|
|
def public_addresses(self, controllers):
|
|
return dict(map(
|
|
lambda x: (x.name, x.get_ip_address_by_network_name('public')),
|
|
controllers))
|
|
|
|
def internal_addresses(self, controllers):
|
|
return dict(map(
|
|
lambda x: (x.name, x.get_ip_address_by_network_name('internal')),
|
|
controllers))
|
|
|
|
def addresses(self, nodes):
|
|
return dict(map(
|
|
lambda x:
|
|
(str(x.name),
|
|
{
|
|
'internal_address': x.get_ip_address_by_network_name('internal'),
|
|
'public_address': x.get_ip_address_by_network_name('public'),
|
|
},
|
|
),
|
|
nodes)
|
|
)
|
|
|
|
def generate_dns_nameservers_list(self, ci):
|
|
return map(
|
|
lambda x: x.get_ip_address_by_network_name('internal'), ci.nodes().cobblers)
|
|
|
|
def describe_node(self, node, role):
|
|
return {'name': str(node.name), 'role' : role,
|
|
'internal_address': node.get_ip_address_by_network_name('internal'),'public_address': node.get_ip_address_by_network_name('public'),}
|
|
|
|
def describe_swift_node(self, node, role, zone):
|
|
node_dict = self.describe_node(node, role)
|
|
node_dict.update({'swift_zone': zone})
|
|
return node_dict
|
|
|
|
def generate_nodes_configs_list(self, ci):
|
|
zones = range(1, 50)
|
|
nodes = []
|
|
for node in ci.nodes().computes: nodes.append(self.describe_node(node, 'compute'))
|
|
for node in ci.nodes().controllers: nodes.append(self.describe_swift_node(node, 'controller', zones.pop()))
|
|
for node in ci.nodes().storages: nodes.append(self.describe_swift_node(node, 'storage', zones.pop()))
|
|
for node in ci.nodes().proxies: nodes.append(self.describe_node(node, 'swift-proxy'))
|
|
for node in ci.nodes().quantums: nodes.append(self.describe_node(node, 'quantum'))
|
|
for node in ci.nodes().masters: nodes.append(self.describe_node(node, 'master'))
|
|
for node in ci.nodes().cobblers: nodes.append(self.describe_node(node, 'cobbler'))
|
|
for node in ci.nodes().stomps: nodes.append(self.describe_node(node, 'stomp'))
|
|
return nodes
|
|
|
|
def self_test(self):
|
|
class Node(object):
|
|
def __init__(self, name):
|
|
super(Node, self).__init__()
|
|
self.name = name
|
|
def get_ip_address_by_network_name(self, name):
|
|
return '10.0.55.66'
|
|
print self.addresses([Node('fuel-controller-01'), Node('fuel-controller-02')])
|
|
|
|
def external_ip_info(self, ci, quantums):
|
|
floating_network = IPNetwork(ci.floating_network())
|
|
return {
|
|
'public_net_router' : ci.public_router(),
|
|
'ext_bridge' : quantums[0].get_ip_address_by_network_name('public'),
|
|
'pool_start' : floating_network[2],
|
|
'pool_end' : floating_network[-2]
|
|
}
|
|
|
|
def hostnames(self, controllers):
|
|
return [x.name for x in controllers]
|
|
|
|
def public_interface(self):
|
|
return INTERFACES['public']
|
|
|
|
def internal_interface(self):
|
|
return INTERFACES['internal']
|
|
|
|
def private_interface(self):
|
|
return INTERFACES['private']
|
|
|
|
def physical_volumes(self):
|
|
return ["/dev/vdb"]
|
|
|
|
def loopback(self, loopback):
|
|
return "loopback" if loopback else False
|
|
|
|
def floating_network(self, ci, quantum):
|
|
if quantum:
|
|
return ci.public_network()
|
|
else:
|
|
return ci.floating_network()
|
|
|
|
def fixed_network(self, ci, quantum):
|
|
if quantum:
|
|
return '192.168.111.0/24'
|
|
else:
|
|
return ci.fixed_network()
|
|
|
|
def write_openstack_simple_manifest(self, remote, ci, controllers,
|
|
use_syslog=True,
|
|
quantum=True,
|
|
cinder=True, cinder_on_computes=False):
|
|
template = Template(
|
|
root(
|
|
'deployment', 'puppet', 'openstack', 'examples',
|
|
'site_openstack_simple.pp')).replace(
|
|
floating_range=self.floating_network(ci, quantum),
|
|
fixed_range=self.fixed_network(ci, quantum),
|
|
public_interface=self.public_interface(),
|
|
internal_interface=self.internal_interface(),
|
|
private_interface=self.private_interface(),
|
|
mirror_type=self.mirror_type(),
|
|
#controller_node_address=controllers[0].get_ip_address_by_network_name('internal'),
|
|
#controller_node_public=controllers[0].get_ip_address_by_network_name('public'),
|
|
cinder=cinder,
|
|
cinder_on_computes=cinder_on_computes,
|
|
nv_physical_volume=self.physical_volumes(),
|
|
nagios_master = controllers[0].name + '.your-domain-name.com',
|
|
external_ipinfo=self.external_ip_info(ci, controllers),
|
|
nodes=self.generate_nodes_configs_list(ci),
|
|
dns_nameservers=self.generate_dns_nameservers_list(ci),
|
|
ntp_servers=['pool.ntp.org',ci.internal_router()],
|
|
default_gateway=ci.public_router(),
|
|
enable_test_repo=TEST_REPO,
|
|
deployment_id = self.deployment_id(ci),
|
|
use_syslog=use_syslog,
|
|
public_netmask = ci.public_net_mask(),
|
|
internal_netmask = ci.internal_net_mask(),
|
|
)
|
|
if is_not_essex():
|
|
template.replace(
|
|
quantum=quantum,
|
|
quantum_netnode_on_cnt=quantum,
|
|
)
|
|
self.write_manifest(remote, template)
|
|
|
|
|
|
def write_openstack_single_manifest(self, remote, ci,
|
|
use_syslog=True,
|
|
quantum=True,
|
|
cinder=True):
|
|
template = Template(
|
|
root(
|
|
'deployment', 'puppet', 'openstack', 'examples',
|
|
'site_openstack_single.pp')).replace(
|
|
floating_range=self.floating_network(ci, quantum),
|
|
fixed_range=self.fixed_network(ci, quantum),
|
|
public_interface=self.public_interface(),
|
|
private_interface=self.private_interface(),
|
|
mirror_type=self.mirror_type(),
|
|
use_syslog=use_syslog,
|
|
cinder=cinder,
|
|
ntp_servers=['pool.ntp.org',ci.internal_router()],
|
|
quantum=quantum,
|
|
enable_test_repo = TEST_REPO,
|
|
)
|
|
self.write_manifest(remote, template)
|
|
|
|
|
|
def write_openstack_ha_minimal_manifest(self, remote, template, ci, controllers, quantums,
|
|
proxies=None, use_syslog=True,
|
|
quantum=True, loopback=True,
|
|
cinder=True, cinder_on_computes=False, quantum_netnode_on_cnt=True,
|
|
ha_provider='pacemaker'):
|
|
template.replace(
|
|
internal_virtual_ip=ci.internal_virtual_ip(),
|
|
public_virtual_ip=ci.public_virtual_ip(),
|
|
floating_range=self.floating_network(ci, quantum),
|
|
fixed_range=self.fixed_network(ci,quantum),
|
|
mirror_type=self.mirror_type(),
|
|
public_interface=self.public_interface(),
|
|
internal_interface=self.internal_interface(),
|
|
private_interface=self.private_interface(),
|
|
nv_physical_volume=self.physical_volumes(),
|
|
use_syslog=use_syslog,
|
|
cinder=cinder,
|
|
cinder_on_computes=cinder_on_computes,
|
|
nagios_master = controllers[0].name + '.your-domain-name.com',
|
|
external_ipinfo=self.external_ip_info(ci, quantums),
|
|
nodes=self.generate_nodes_configs_list(ci),
|
|
dns_nameservers=self.generate_dns_nameservers_list(ci),
|
|
default_gateway=ci.public_router(),
|
|
ntp_servers=['pool.ntp.org',ci.internal_router()],
|
|
enable_test_repo=TEST_REPO,
|
|
deployment_id = self.deployment_id(ci),
|
|
public_netmask = ci.public_net_mask(),
|
|
internal_netmask = ci.internal_net_mask(),
|
|
)
|
|
if is_not_essex():
|
|
template.replace(
|
|
quantum=quantum,
|
|
quantum_netnode_on_cnt=quantum_netnode_on_cnt,
|
|
ha_provider=ha_provider,
|
|
)
|
|
|
|
self.write_manifest(remote, template)
|
|
|
|
|
|
def write_openstack_manifest(self, remote, template, ci, controllers, quantums,
|
|
proxies=None, use_syslog=True,
|
|
quantum=True, loopback=True,
|
|
cinder=True, swift=True, quantum_netnode_on_cnt=True,
|
|
ha_provider='pacemaker'):
|
|
template.replace(
|
|
internal_virtual_ip=ci.internal_virtual_ip(),
|
|
public_virtual_ip=ci.public_virtual_ip(),
|
|
floating_range=self.floating_network(ci, quantum),
|
|
fixed_range=self.fixed_network(ci,quantum),
|
|
mirror_type=self.mirror_type(),
|
|
public_interface=self.public_interface(),
|
|
internal_interface=self.internal_interface(),
|
|
private_interface=self.private_interface(),
|
|
nv_physical_volume=self.physical_volumes(),
|
|
use_syslog=use_syslog,
|
|
cinder=cinder,
|
|
ntp_servers=['pool.ntp.org',ci.internal_router()],
|
|
cinder_on_computes=cinder,
|
|
nagios_master = controllers[0].name + '.your-domain-name.com',
|
|
external_ipinfo=self.external_ip_info(ci, quantums),
|
|
nodes=self.generate_nodes_configs_list(ci),
|
|
dns_nameservers=self.generate_dns_nameservers_list(ci),
|
|
default_gateway=ci.public_router(),
|
|
enable_test_repo=TEST_REPO,
|
|
deployment_id = self.deployment_id(ci),
|
|
public_netmask = ci.public_net_mask(),
|
|
internal_netmask = ci.internal_net_mask(),
|
|
)
|
|
if swift:
|
|
template.replace(swift_loopback=self.loopback(loopback))
|
|
if is_not_essex():
|
|
template.replace(
|
|
quantum=quantum,
|
|
quantum_netnode_on_cnt=quantum_netnode_on_cnt,
|
|
ha_provider=ha_provider,
|
|
)
|
|
|
|
self.write_manifest(remote, template)
|
|
|
|
|
|
def write_swift_manifest(self, remote, controllers,
|
|
proxies=None):
|
|
template = Template(
|
|
root('deployment', 'puppet', 'swift', 'examples',
|
|
'site.pp'))
|
|
template.replace(
|
|
swift_proxy_address=proxies[0].get_ip_address_by_network_name(
|
|
'internal'),
|
|
controller_node_public=controllers[
|
|
0].get_ip_address_by_network_name(
|
|
'public'),
|
|
)
|
|
self.write_manifest(remote, template)
|
|
|
|
def write_cobbler_manifest(self, remote, ci, cobblers):
|
|
site_pp = Template(root('deployment', 'puppet', 'cobbler', 'examples',
|
|
'server_site.pp'))
|
|
cobbler = cobblers[0]
|
|
cobbler_address = cobbler.get_ip_address_by_network_name('internal')
|
|
network = IPNetwork(ci.environment().network_by_name(
|
|
'internal').ip_network)
|
|
site_pp.replace(
|
|
server=cobbler_address,
|
|
name_server=cobbler_address,
|
|
next_server=cobbler_address,
|
|
dhcp_start_address=network[5],
|
|
dhcp_end_address=network[-1],
|
|
dhcp_netmask=network.netmask,
|
|
dhcp_gateway=network[1],
|
|
pxetimeout='3000',
|
|
mirror_type=self.mirror_type(),
|
|
)
|
|
self.write_manifest(remote, site_pp)
|
|
|
|
def write_stomp_manifest(self, remote):
|
|
self.write_manifest(remote, Template.stomp().replace(
|
|
mirror_type=self.mirror_type()
|
|
))
|
|
|
|
def write_nagios_manifest(self, remote):
|
|
self.write_manifest(remote, Template.nagios())
|
|
|
|
def deployment_id(self, ci):
|
|
try:
|
|
return str(int(ci.internal_network().split('.')[2]) + 1)
|
|
except:
|
|
return '250'
|