freeipa/ipatests/test_integration/config.py

349 lines
13 KiB
Python

# Authors:
# Petr Viktorin <pviktori@redhat.com>
# Tomas Babej <tbabej@redhat.com>
#
# Copyright (C) 2013 Red Hat
# see file 'COPYING' for use and warranty information
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""Utilities for configuration of multi-master tests"""
import os
import collections
import random
from ipapython import ipautil
from ipapython.dn import DN
from ipapython.ipa_log_manager import log_mgr
from ipatests.test_integration.host import BaseHost
class Config(object):
def __init__(self, **kwargs):
self.log = log_mgr.get_logger(self)
admin_password = kwargs.get('admin_password') or 'Secret123'
self.test_dir = kwargs.get('test_dir', '/root/ipatests')
self.root_password = kwargs.get('root_password')
self.root_ssh_key_filename = kwargs.get('root_ssh_key_filename')
self.ipv6 = bool(kwargs.get('ipv6', False))
self.debug = bool(kwargs.get('debug', False))
self.admin_name = kwargs.get('admin_name') or 'admin'
self.admin_password = admin_password
self.dirman_dn = DN(kwargs.get('dirman_dn') or 'cn=Directory Manager')
self.dirman_password = kwargs.get('dirman_password') or admin_password
self.admin_name = kwargs.get('admin_name') or 'admin'
# 8.8.8.8 is probably the best-known public DNS
self.dns_forwarder = kwargs.get('dns_forwarder') or '8.8.8.8'
self.nis_domain = kwargs.get('nis_domain') or 'ipatest'
self.ntp_server = kwargs.get('ntp_server') or (
'%s.pool.ntp.org' % random.randint(0, 3))
self.ad_admin_name = kwargs.get('ad_admin_name') or 'Administrator'
self.ad_admin_password = kwargs.get('ad_admin_password') or 'Secret123'
if not self.root_password and not self.root_ssh_key_filename:
self.root_ssh_key_filename = '~/.ssh/id_rsa'
self.domains = []
@property
def ad_domains(self):
return filter(lambda d: d.type == 'AD', self.domains)
@classmethod
def from_env(cls, env):
"""Create a test config from environment variables
Input variables:
DOMAIN: the domain to install in
IPATEST_DIR: Directory on which test-specific files will be stored,
by default /root/ipatests
IPv6SETUP: "TRUE" if setting up with IPv6
IPADEBUG: non-empty if debugging is turned on
IPA_ROOT_SSH_KEY: File with root's private RSA key for SSH
(default: ~/.ssh/id_rsa)
IPA_ROOT_SSH_PASSWORD: SSH password for root
(used if IPA_ROOT_SSH_KEY is not set)
ADMINID: Administrator username
ADMINPW: Administrator password
ROOTDN: Directory Manager DN
ROOTDNPWD: Directory Manager password
ADADMINID: Active Directory Administrator username
ADADMINPW: Active Directory Administrator password
DNSFORWARD: DNS forwarder
NISDOMAIN
NTPSERVER
MASTER_env1: FQDN of the master
REPLICA_env1: space-separated FQDNs of the replicas
CLIENT_env1: space-separated FQDNs of the clients
AD_env1: space-separated FQDNs of the Active Directories
OTHER_env1: space-separated FQDNs of other hosts
(same for _env2, _env3, etc)
BEAKERREPLICA1_IP_env1: IP address of replica 1 in env 1
(same for MASTER, CLIENT)
Also see env_normalize() for alternate variable names
"""
env_normalize(env)
self = cls(test_dir=env.get('IPATEST_DIR') or '/root/ipatests',
ipv6=(env.get('IPv6SETUP') == 'TRUE'),
debug=env.get('IPADEBUG'),
root_password=env.get('IPA_ROOT_SSH_PASSWORD'),
root_ssh_key_filename=env.get('IPA_ROOT_SSH_KEY'),
admin_name=env.get('ADMINID'),
admin_password=env.get('ADMINPW'),
dirman_dn=env.get('ROOTDN'),
dirman_password=env.get('ROOTDNPWD'),
dns_forwarder=env.get('DNSFORWARD'),
nis_domain=env.get('NISDOMAIN'),
ntp_server=env.get('NTPSERVER'),
ad_admin_name=env.get('ADADMINID'),
ad_admin_password=env.get('ADADMINPW'),
)
# Either IPA master or AD can define a domain
domain_index = 1
while (env.get('MASTER_env%s' % domain_index) or
env.get('AD_env%s' % domain_index)):
if env.get('MASTER_env%s' % domain_index):
# IPA domain takes precedence to AD domain in case of conflict
self.domains.append(Domain.from_env(env, self, domain_index,
domain_type='IPA'))
else:
self.domains.append(Domain.from_env(env, self, domain_index,
domain_type='AD'))
domain_index += 1
return self
def to_env(self, simple=True):
"""Convert this test config into environment variables"""
try:
env = collections.OrderedDict()
except AttributeError:
# Older Python versions
env = {}
env['IPATEST_DIR'] = self.test_dir
env['IPv6SETUP'] = 'TRUE' if self.ipv6 else ''
env['IPADEBUG'] = 'TRUE' if self.debug else ''
env['IPA_ROOT_SSH_PASSWORD'] = self.root_password or ''
env['IPA_ROOT_SSH_KEY'] = self.root_ssh_key_filename or ''
env['ADMINID'] = self.admin_name
env['ADMINPW'] = self.admin_password
env['ROOTDN'] = str(self.dirman_dn)
env['ROOTDNPWD'] = self.dirman_password
env['ADADMINID'] = self.ad_admin_name
env['ADADMINPW'] = self.ad_admin_password
env['DNSFORWARD'] = self.dns_forwarder
env['NISDOMAIN'] = self.nis_domain
env['NTPSERVER'] = self.ntp_server
for domain in self.domains:
env['DOMAIN%s' % domain._env] = domain.name
env['RELM%s' % domain._env] = domain.realm
env['BASEDN%s' % domain._env] = str(domain.basedn)
for role, hosts in [('MASTER', domain.masters),
('REPLICA', domain.replicas),
('CLIENT', domain.clients),
('AD', domain.ads),
('OTHER', domain.other_hosts)]:
hostnames = ' '.join(h.hostname for h in hosts)
env['%s%s' % (role, domain._env)] = hostnames
ext_hostnames = ' '.join(h.external_hostname for h in hosts)
env['BEAKER%s%s' % (role, domain._env)] = ext_hostnames
ips = ' '.join(h.ip for h in hosts)
env['BEAKER%s_IP%s' % (role, domain._env)] = ips
for i, host in enumerate(hosts, start=1):
suffix = '%s%s' % (role, i)
ext_hostname = host.external_hostname
env['%s%s' % (suffix, domain._env)] = host.hostname
env['BEAKER%s%s' % (suffix, domain._env)] = ext_hostname
env['BEAKER%s_IP%s' % (suffix, domain._env)] = host.ip
if simple:
# Simple Vars for simplicity and backwards compatibility with older
# tests. This means no _env<NUM> suffix.
if self.domains:
default_domain = self.domains[0]
if default_domain.master:
env['MASTER'] = default_domain.master.hostname
env['BEAKERMASTER'] = default_domain.master.external_hostname
env['MASTERIP'] = default_domain.master.ip
env['SLAVE'] = env['REPLICA'] = env['REPLICA_env1']
env['BEAKERSLAVE'] = env['BEAKERREPLICA_env1']
env['SLAVEIP'] = env['BEAKERREPLICA_IP_env1']
if default_domain.clients:
client = default_domain.clients[0]
env['CLIENT'] = client.hostname
env['BEAKERCLIENT'] = client.external_hostname
if len(default_domain.clients) >= 2:
client = default_domain.clients[1]
env['CLIENT2'] = client.hostname
env['BEAKERCLIENT2'] = client.external_hostname
return env
def host_by_name(self, name):
for domain in self.domains:
try:
return domain.host_by_name(name)
except LookupError:
pass
raise LookupError(name)
def env_normalize(env):
"""Fill env variables from alternate variable names
MASTER_env1 <- MASTER
REPLICA_env1 <- REPLICA
CLIENT_env1 <- CLIENT, SLAVE
CLIENT_env1 gets extended with CLIENT2 or CLIENT2_env1
"""
def coalesce(name, *other_names):
"""If name is not set, set it to first existing env[other_name]"""
if name not in env:
for other_name in other_names:
try:
env[name] = env[other_name]
except KeyError:
pass
else:
return
else:
env[name] = ''
coalesce('MASTER_env1', 'MASTER')
coalesce('REPLICA_env1', 'REPLICA')
coalesce('CLIENT_env1', 'CLIENT', 'SLAVE')
def extend(name, name2):
value = env.get(name2)
if value:
env[name] += ' ' + value
extend('CLIENT_env1', 'CLIENT2')
extend('CLIENT_env1', 'CLIENT2_env1')
class Domain(object):
"""Configuration for an IPA / AD domain"""
def __init__(self, config, name, index, domain_type):
self.log = log_mgr.get_logger(self)
self.type = domain_type
self.config = config
self.name = name
self.hosts = []
self.index = index
self._env = '_env%s' % index
self.realm = self.name.upper()
self.basedn = DN(*(('dc', p) for p in name.split('.')))
@classmethod
def from_env(cls, env, config, index, domain_type):
# Roles available in the domain depend on the type of the domain
# Unix machines are added only to the IPA domains, Windows machines
# only to the AD domains
if domain_type == 'IPA':
master_role = 'MASTER'
domain_roles = 'master', 'replica', 'client', 'other'
else:
master_role = 'AD'
domain_roles = 'ad',
master_env = '%s_env%s' % (master_role, index)
hostname, dot, domain_name = env[master_env].partition('.')
self = cls(config, domain_name, index, domain_type)
for role in domain_roles:
value = env.get('%s%s' % (role.upper(), self._env), '')
for index, hostname in enumerate(value.split(), start=1):
host = BaseHost.from_env(env, self, hostname, role, index)
self.hosts.append(host)
if not self.hosts:
raise ValueError('No hosts defined for %s' % self._env)
return self
def to_env(self, **kwargs):
"""Return environment variables specific to this domain"""
env = self.config.to_env(**kwargs)
env['DOMAIN'] = self.name
env['RELM'] = self.realm
env['BASEDN'] = str(self.basedn)
return env
@property
def master(self):
return self.masters[0]
@property
def masters(self):
return [h for h in self.hosts if h.role == 'master']
@property
def replicas(self):
return [h for h in self.hosts if h.role == 'replica']
@property
def clients(self):
return [h for h in self.hosts if h.role == 'client']
@property
def ads(self):
return [h for h in self.hosts if h.role == 'ad']
@property
def other_hosts(self):
return [h for h in self.hosts
if h.role not in ('master', 'client', 'replica', 'ad')]
def host_by_name(self, name):
for host in self.hosts:
if name in (host.hostname, host.external_hostname, host.shortname):
return host
raise LookupError(name)
def env_to_script(env):
return ''.join(['export %s=%s\n' % (key, ipautil.shell_quote(value))
for key, value in env.items()])
def get_global_config():
return Config.from_env(os.environ)