def stop():
ldap_env = LdapEnv.get()
if ldap_env.is_tmp_daemon:
pid = ldap_env.get_pid()
if pid:
proc.sh_kill_wait(pid, 'slapd', sudo=True)
else:
env.sudo('service slapd stop')
def start():
ldap_env = LdapEnv.get()
if ldap_env.is_tmp_daemon:
args = ldap_env.slapd_args
args = ' '.join(args)
with warn_only():
proc.run_cmd(args, sudo=True)
else:
env.sudo('service slapd start')
def __enter__(self):
# Teardown system slapd
ldap.teardown(stop=True)
ldap_env = LdapEnv.get()
ldap_env.is_tmp_daemon = True
env.ldap_env = ldap_env
# Start tmp daemon
actions.start()
return self
def unload_schema():
ldap_env = LdapEnv.get()
schema_dir = join(ldap_env.cn_config_path, 'cn=schema')
files = fs.sh_listdir(schema_dir, sudo=True)
files = fnmatch.filter(files, 'cn={*}%s.ldif' % env.ldap_custom_schema_cn)
if not files:
putw('Failed to detect schema: {0}'.format(env.ldap_custom_schema_cn))
else:
filepath = join(schema_dir, files[0])
puth('Removing schema {0}'.format(filepath))
fs.sh_rm(filepath, sudo=True)
def get_ldap_bootstrap_script(distro):
ldap_env = LdapEnv(distro)
context = {
'__DIT_ADMIN_DN__': env.ldap_admin_dn,
'__ADMIN_PW__': env.ldap_admin_pw,
'__LDAP_GROUP__': ldap_env.ldap_group,
'__LDAP_USER__': ldap_env.ldap_user,
'__ETC_LDAP__': ldap_env.etc_path,
'__ETC_LDAP_SCHEMA__': ldap_env.schema_path,
'__ETC_LDAP_SLAPDD__': ldap_env.slapdd_path,
'__USR_LIB_LDAP_LOCS__': ' '.join(ldap_env.module_path_locs),
'__VAR_LIB_LDAP__': ldap_env.database_rootdir,
}
return get_ldap_tmpl('bootstrap-ldap.sh', context)
def create_database():
ldap_env = LdapEnv.get()
if not fs.sh_dir_exists(ldap_env.database_path, sudo=True):
puth('Creating database directory {0}'.format(ldap_env.database_path))
fs.sh_makedirs(ldap_env.database_path,
user=ldap_env.ldap_user,
group=ldap_env.ldap_group,
sudo=True)
with fs.mkstemp() as fp:
content = ldif.get_database()
open(fp, 'wt').write(content)
puth('Creating database config for {0}'.format(env.ldap_database_name))
env.sudo('ldapadd -Y EXTERNAL -H ldapi:/// -f {0}'.format(fp))
def get_database():
ldap_env = LdapEnv.get()
indexes = ''
for fname, vals in sorted(env.ldap_indexes.items()):
indexes += 'olcDbIndex: {0} {1}\n'.format(fname, vals)
pw_hash = env.sudo('slappasswd -s {0}'.format(env.ldap_admin_pw), capture=True)
context = {
'__DB_PATH__': ldap_env.database_path,
'__DIT_DN__': env.ldap_dit_dn,
'__DIT_ADMIN_DN__': env.ldap_admin_dn,
'__ADMIN_PW__': pw_hash,
'__LDAP_INDEXES__': indexes,
}
return get_ldap_tmpl('database.ldif', context)
def get_database():
ldap_env = LdapEnv.get()
indexes = ''
for fname, vals in sorted(env.ldap_indexes.items()):
indexes += 'olcDbIndex: {0} {1}\n'.format(fname, vals)
pw_hash = env.sudo('slappasswd -s {0}'.format(env.ldap_admin_pw),
capture=True)
context = {
'__DB_PATH__': ldap_env.database_path,
'__DIT_DN__': env.ldap_dit_dn,
'__DIT_ADMIN_DN__': env.ldap_admin_dn,
'__ADMIN_PW__': pw_hash,
'__LDAP_INDEXES__': indexes,
}
return get_ldap_tmpl('database.ldif', context)
def unload_modules():
ldap_env = LdapEnv.get()
for name in env.ldap_modules:
filepath = None
files = fs.sh_listdir(ldap_env.cn_config_path, sudo=True)
files = fnmatch.filter(files, 'cn=module{*}.ldif')
for f in files:
fp = join(ldap_env.cn_config_path, f)
if fs.sh_file_exists(fp, sudo=True):
content = fs.sh_cat(fp, sudo=True)
if text.safefind('(?m)^olcModuleLoad: {[0-9]+}' + name, content):
filepath = fp
if not filepath:
putw('Failed to detect loaded module: {0}'.format(name))
else:
puth('Removing module {0}'.format(name))
fs.sh_rm(filepath, sudo=True)
def get_zarafa_schema():
ldap_env = LdapEnv.get()
with fs.mkdtemp() as d:
shutil.copyfile(join(env.ldap_schema_dir, 'zarafa.schema'),
join(d, 'zarafa.schema'))
context = {
'include\s+zarafa\.schema':
'include {0}'.format(join(d, 'zarafa.schema')),
'__LDAP_ETC_PATH__':
ldap_env.etc_path_orig,
}
conv_fp = join(d, 'schema_convert.conf')
text.patch_file(context,
join(env.ldap_schema_dir, 'schema_convert.conf.in'),
dest=conv_fp,
literal=False)
# debian6: fails to find slaptest without abs path
env.run('/usr/sbin/slaptest -f {0} -F {1}'.format(conv_fp, d))
ldif_file = join(d, 'cn=config', 'cn=schema', 'cn={4}zarafa.ldif')
context = {
'(?m)^structuralObjectClass: .*$': '',
'(?m)^entryUUID: .*$': '',
'(?m)^creatorsName: .*$': '',
'(?m)^createTimestamp: .*$': '',
'(?m)^entryCSN: .*$': '',
'(?m)^modifiersName: .*$': '',
'(?m)^modifyTimestamp: .*$': '',
'(?m)^dn: .*': 'dn: {0}'.format(env.ldap_custom_schema_dn),
'(?m)^cn: .*': 'cn: {0}'.format(env.ldap_custom_schema_cn),
}
text.patch_file(context, ldif_file, dest=ldif_file, literal=False)
content = open(ldif_file, 'rt').read()
return content.strip()
def get_slapd_conf(distro):
ldap_env = LdapEnv(distro)
def tabbed_line_join(data, prefix='', sort=False):
tuples = data
if type(data) == dict:
tuples = data.items()
if sort:
tuples = sorted(tuples)
return '\n'.join([
'{0}{1:30} {2}'.format(prefix, name, props)
for (name, props) in tuples
])
confs = [get_mod_memberof_config(), get_mod_refint_config()]
moduleconf = '\n\n'.join([tabbed_line_join(c) for c in confs])
modules = '\n'.join(
['moduleload\t{0}'.format(name) for name in env.ldap_modules])
indexes = tabbed_line_join(env.ldap_indexes, prefix='index\t', sort=True)
context = {
'__DIT_DN__': env.ldap_dit_dn,
'__DIT_ADMIN_DN__': env.ldap_admin_dn,
'__ADMIN_PW__': env.ldap_admin_pw,
'__INDEXES__': indexes,
'__MODULES__': modules,
'__MODULECONF__': moduleconf,
'__ARGSFILE__': ldap_env.argsfile,
'__ETC_LDAP__': ldap_env.etc_path,
'__PIDFILE__': ldap_env.pidfile,
'__VAR_LIB_LDAP__': ldap_env.database_rootdir,
}
return get_ldap_tmpl('slapd.conf', context)
def get_zarafa_schema():
ldap_env = LdapEnv.get()
with fs.mkdtemp() as d:
shutil.copyfile(
join(env.ldap_schema_dir, 'zarafa.schema'),
join(d, 'zarafa.schema'))
context = {
'include\s+zarafa\.schema': 'include {0}'.format(join(d, 'zarafa.schema')),
'__LDAP_ETC_PATH__': ldap_env.etc_path_orig,
}
conv_fp = join(d, 'schema_convert.conf')
text.patch_file(context,
join(env.ldap_schema_dir, 'schema_convert.conf.in'),
dest=conv_fp, literal=False)
# debian6: fails to find slaptest without abs path
env.run('/usr/sbin/slaptest -f {0} -F {1}'.format(conv_fp, d))
ldif_file = join(d, 'cn=config', 'cn=schema', 'cn={4}zarafa.ldif')
context = {
'(?m)^structuralObjectClass: .*$': '',
'(?m)^entryUUID: .*$': '',
'(?m)^creatorsName: .*$': '',
'(?m)^createTimestamp: .*$': '',
'(?m)^entryCSN: .*$': '',
'(?m)^modifiersName: .*$': '',
'(?m)^modifyTimestamp: .*$': '',
'(?m)^dn: .*': 'dn: {0}'.format(env.ldap_custom_schema_dn),
'(?m)^cn: .*': 'cn: {0}'.format(env.ldap_custom_schema_cn),
}
text.patch_file(context, ldif_file, dest=ldif_file, literal=False)
content = open(ldif_file, 'rt').read()
return content.strip()
def drop_database():
ldap_env = LdapEnv.get()
files = fs.sh_listdir(ldap_env.cn_config_path, sudo=True)
files = fnmatch.filter(files, 'olcDatabase={*}hdb.ldif')
filepath = None
for f in files:
fp = join(ldap_env.cn_config_path, f)
content = fs.sh_cat(fp, sudo=True)
if text.safefind('(?m)^olcSuffix: ' + env.ldap_dit_dn, content):
filepath = fp
if not filepath:
putw('Failed to detect database: {0}'.format(env.ldap_dit_dn))
else:
puth('Removing database config {0}'.format(filepath))
fs.sh_rm(filepath, sudo=True)
root, _ = os.path.splitext(filepath)
if fs.sh_dir_exists(root, sudo=True):
puth('Removing database config subdir {0}'.format(root))
fs.sh_rmtree(root, sudo=True)
def delete_database_storage():
ldap_env = LdapEnv.get()
if fs.sh_dir_exists(ldap_env.database_path, sudo=True):
puth('Deleting database directory {0}'.format(ldap_env.database_path))
fs.sh_rmtree(ldap_env.database_path, sudo=True)