if (settings->targetdir != NULL)
PyDict_SetItemString(parameters, "targetdir",
PyString_FromString(settings->targetdir));
- PyDict_SetItemString(parameters, "setup_dir",
- PyString_FromString(dyn_SETUPDIR));
PyDict_SetItemString(parameters, "hostname",
PyString_FromString(settings->netbios_name));
PyDict_SetItemString(parameters, "domain",
parameters = PyDict_New();
- PyDict_SetItemString(parameters, "setup_dir",
- PyString_FromString(dyn_SETUPDIR));
if (override_prefixmap) {
PyDict_SetItemString(parameters, "override_prefixmap",
PyString_FromStringAndSize((const char *)override_prefixmap->data,
#include "param/param.h"
#include "param/loadparm.h"
#include "lib/talloc/pytalloc.h"
+#include "dynconfig/dynconfig.h"
/* There's no Py_ssize_t in 2.4, apparently */
#if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5
return PyString_FromString(lp_default_path());
}
+static PyObject *py_setup_dir(PyObject *self)
+{
+ return PyString_FromString(dyn_SETUPDIR);
+}
+
static PyMethodDef pyparam_methods[] = {
{ "default_path", (PyCFunction)py_default_path, METH_NOARGS,
"Returns the default smb.conf path." },
+ { "setup_dir", (PyCFunction)py_setup_dir, METH_NOARGS,
+ "Returns the compiled in location of provision tempates." },
{ NULL }
};
FLAG_MOD_REPLACE, FLAG_MOD_ADD, FLAG_MOD_DELETE,
MessageElement, Message, Dn)
from samba import param, dsdb, Ldb
-from samba.provision import (find_setup_dir, get_domain_descriptor,
+from samba.provision import (get_domain_descriptor,
get_config_descriptor,
ProvisioningError, get_last_provision_usn,
get_max_usn, update_provision_usn)
creds = credopts.get_credentials(lp)
creds.set_kerberos_state(DONT_USE_KERBEROS)
-setup_dir = opts.setupdir
-if setup_dir is None:
- setup_dir = find_setup_dir()
increment_calculated_keyversion_number(samdb, names.rootdn,
hash["msDs-KeyVersionNumber"])
-def setup_path(file):
- return os.path.join(setup_dir, file)
-
# Synopsis for updateprovision
# 1) get path related to provision to be update (called current)
# 2) open current provision ldbs
# From here start the big steps of the program
# 1) First get files paths
paths = get_paths(param, smbconf=smbconf)
- paths.setup = setup_dir
# Get ldbs with the system session, it is needed for searching
# provision parameters
session = system_session()
message(SIMPLE, "Creating a reference provision")
provisiondir = tempfile.mkdtemp(dir=paths.private_dir,
prefix="referenceprovision")
- newprovision(names, setup_dir, creds, session, smbconf, provisiondir,
+ newprovision(names, creds, session, smbconf, provisiondir,
provision_logger)
# TODO
new_ldbs.startTransactions()
# 12)
- schema = Schema(setup_path, names.domainsid, schemadn=str(names.schemadn))
+ schema = Schema(names.domainsid, schemadn=str(names.schemadn))
# We create a closure that will be invoked just before schema reload
def schemareloadclosure():
basesam = Ldb(paths.samdb, session_info=session, credentials=creds, lp=lp,
from samba.ndr import ndr_pack
from samba.dcerpc import security, drsuapi, misc, nbt
from samba.credentials import Credentials, DONT_USE_KERBEROS
-from samba.provision import secretsdb_self_join, provision, FILL_DRS, find_setup_dir
+from samba.provision import secretsdb_self_join, provision, FILL_DRS
from samba.schema import Schema
from samba.net import Net
import logging
ctx.acct_dn = "CN=%s,OU=Domain Controllers,%s" % (ctx.myname, ctx.base_dn)
- ctx.setup_dir = find_setup_dir()
ctx.tmp_samdb = None
ctx.SPNs = [ "HOST/%s" % ctx.myname,
def create_tmp_samdb(ctx):
'''create a temporary samdb object for schema queries'''
- def setup_path(file):
- return os.path.join(ctx.setup_dir, file)
- ctx.tmp_schema = Schema(setup_path, security.dom_sid(ctx.domsid),
+ ctx.tmp_schema = Schema(security.dom_sid(ctx.domsid),
schemadn=ctx.schema_dn)
ctx.tmp_samdb = SamDB(session_info=system_session(), url=None, auto_connect=False,
credentials=ctx.creds, lp=ctx.lp, global_schema=False,
logger.addHandler(logging.StreamHandler(sys.stdout))
smbconf = ctx.lp.configfile
- presult = provision(ctx.setup_dir, logger, system_session(), None,
+ presult = provision(logger, system_session(), None,
smbconf=smbconf, targetdir=ctx.targetdir, samdb_fill=FILL_DRS,
realm=ctx.realm, rootdn=ctx.root_dn, domaindn=ctx.base_dn,
schemadn=ctx.schema_dn,
LAST_PROVISION_USN_ATTRIBUTE = "lastProvisionUSN"
-def find_setup_dir():
- """Find the setup directory used by provision."""
- if in_source_tree():
- # In source tree
- return os.path.join(source_tree_topdir(), "source4/setup")
- else:
- import sys
- for prefix in [sys.prefix,
- os.path.join(os.path.dirname(__file__), "../../../../..")]:
- for suffix in ["share/setup", "share/samba/setup", "setup"]:
- ret = os.path.normpath(os.path.join(prefix, suffix))
- if os.path.isdir(ret):
- return ret
- raise Exception("Unable to find setup directory.")
+def setup_path(file):
+ """Return an absolute path to the provision tempate file specified by file"""
+ return os.path.join(samba.param.setup_dir(), file)
# Descriptors of naming contexts and other important objects
return names
-def make_smbconf(smbconf, setup_path, hostname, domain, realm, serverrole,
+def make_smbconf(smbconf, hostname, domain, realm, serverrole,
targetdir, sid_generator="internal", eadb=False, lp=None):
"""Create a new smb.conf file based on a couple of basic settings.
"""
idmap.setup_name_mapping(sid + "-513", idmap.TYPE_GID, users_gid)
-def setup_samdb_partitions(samdb_path, setup_path, logger, lp, session_info,
+def setup_samdb_partitions(samdb_path, logger, lp, session_info,
provision_backend, names, schema, serverrole,
erase=False):
"""Setup the partitions for the SAM database.
})
logger.info("Setting up sam.ldb rootDSE")
- setup_samdb_rootdse(samdb, setup_path, names)
+ setup_samdb_rootdse(samdb, names)
except Exception:
samdb.transaction_cancel()
raise
secretsdb.add(msg)
-def secretsdb_setup_dns(secretsdb, setup_path, names, private_dir, realm,
+def secretsdb_setup_dns(secretsdb, names, private_dir, realm,
dnsdomain, dns_keytab_path, dnspass):
"""Add DNS specific bits to a secrets database.
:param secretsdb: Ldb Handle to the secrets database
- :param setup_path: Setup path function
:param machinepass: Machine password
"""
try:
})
-def setup_secretsdb(paths, setup_path, session_info, backend_credentials, lp):
+def setup_secretsdb(paths, session_info, backend_credentials, lp):
"""Setup the secrets database.
:note: This function does not handle exceptions and transaction on purpose,
it's up to the caller to do this job.
:param path: Path to the secrets database.
- :param setup_path: Get the path to a setup file.
:param session_info: Session info.
:param credentials: Credentials
:param lp: Loadparm context
raise
-def setup_privileges(path, setup_path, session_info, lp):
+def setup_privileges(path, session_info, lp):
"""Setup the privileges database.
:param path: Path to the privileges database.
- :param setup_path: Get the path to a setup file.
:param session_info: Session info.
:param credentials: Credentials
:param lp: Loadparm context
privilege_ldb.load_ldif_file_add(setup_path("provision_privilege.ldif"))
-def setup_registry(path, setup_path, session_info, lp):
+def setup_registry(path, session_info, lp):
"""Setup the registry.
:param path: Path to the registry database
- :param setup_path: Function that returns the path to a setup.
:param session_info: Session information
:param credentials: Credentials
:param lp: Loadparm context
reg.diff_apply(provision_reg)
-def setup_idmapdb(path, setup_path, session_info, lp):
+def setup_idmapdb(path, session_info, lp):
"""Setup the idmap database.
:param path: path to the idmap database
- :param setup_path: Function that returns a path to a setup file
:param session_info: Session information
:param credentials: Credentials
:param lp: Loadparm context
return idmap_ldb
-def setup_samdb_rootdse(samdb, setup_path, names):
+def setup_samdb_rootdse(samdb, names):
"""Setup the SamDB rootdse.
:param samdb: Sam Database handle
- :param setup_path: Obtain setup path
"""
setup_add_ldif(samdb, setup_path("provision_rootdse_add.ldif"), {
"SCHEMADN": names.schemadn,
def setup_self_join(samdb, names, machinepass, dnspass,
- domainsid, next_rid, invocationid, setup_path,
+ domainsid, next_rid, invocationid,
policyguid, policyguid_dc, domainControllerFunctionality,
ntdsguid):
"""Join a host to its own domain."""
create_gpo_struct(policy_path)
-def setup_samdb(path, setup_path, session_info, provision_backend, lp, names,
+def setup_samdb(path, session_info, provision_backend, lp, names,
logger, domainsid, domainguid, policyguid, policyguid_dc, fill,
adminpass, krbtgtpass, machinepass, invocationid, dnspass, ntdsguid,
serverrole, am_rodc=False, dom_for_fun_level=None, schema=None,
forestFunctionality = dom_for_fun_level
# Also wipes the database
- setup_samdb_partitions(path, setup_path, logger=logger, lp=lp,
+ setup_samdb_partitions(path, logger=logger, lp=lp,
provision_backend=provision_backend, session_info=session_info,
names=names, serverrole=serverrole, schema=schema)
if schema is None:
- schema = Schema(setup_path, domainsid, schemadn=names.schemadn)
+ schema = Schema(domainsid, schemadn=names.schemadn)
# Load the database, but don's load the global schema and don't connect
# quite yet
next_rid=next_rid,
policyguid=policyguid,
policyguid_dc=policyguid_dc,
- setup_path=setup_path,
domainControllerFunctionality=domainControllerFunctionality,
ntdsguid=ntdsguid)
set_gpos_acl(sysvol, dnsdomain, domainsid, domaindn, samdb, lp)
-def provision(setup_dir, logger, session_info, credentials, smbconf=None,
+def provision(logger, session_info, credentials, smbconf=None,
targetdir=None, samdb_fill=FILL_FULL, realm=None, rootdn=None,
domaindn=None, schemadn=None, configdn=None, serverdn=None,
domain=None, hostname=None, hostip=None, hostip6=None, domainsid=None,
:note: caution, this wipes all existing data!
"""
- def setup_path(file):
- return os.path.join(setup_dir, file)
-
if domainsid is None:
domainsid = security.random_sid()
else:
data = open(smbconf, 'r').read()
data = data.lstrip()
if data is None or data == "":
- make_smbconf(smbconf, setup_path, hostname, domain, realm,
+ make_smbconf(smbconf, hostname, domain, realm,
serverrole, targetdir, sid_generator, useeadb,
lp=lp)
else:
- make_smbconf(smbconf, setup_path, hostname, domain, realm, serverrole,
+ make_smbconf(smbconf, hostname, domain, realm, serverrole,
targetdir, sid_generator, useeadb, lp=lp)
if lp is None:
ldapi_url = "ldapi://%s" % urllib.quote(paths.s4_ldapi_path, safe="")
- schema = Schema(setup_path, domainsid, invocationid=invocationid,
+ schema = Schema(domainsid, invocationid=invocationid,
schemadn=names.schemadn)
if backend_type == "ldb":
provision_backend = LDBBackend(backend_type, paths=paths,
- setup_path=setup_path, lp=lp, credentials=credentials,
+ lp=lp, credentials=credentials,
names=names, logger=logger)
elif backend_type == "existing":
provision_backend = ExistingBackend(backend_type, paths=paths,
- setup_path=setup_path, lp=lp, credentials=credentials,
+ lp=lp, credentials=credentials,
names=names, logger=logger,
ldap_backend_forced_uri=ldap_backend_forced_uri)
elif backend_type == "fedora-ds":
provision_backend = FDSBackend(backend_type, paths=paths,
- setup_path=setup_path, lp=lp, credentials=credentials,
+ lp=lp, credentials=credentials,
names=names, logger=logger, domainsid=domainsid,
schema=schema, hostname=hostname, ldapadminpass=ldapadminpass,
slapd_path=slapd_path,
ldap_backend_forced_uri=ldap_backend_forced_uri)
elif backend_type == "openldap":
provision_backend = OpenLDAPBackend(backend_type, paths=paths,
- setup_path=setup_path, lp=lp, credentials=credentials,
+ lp=lp, credentials=credentials,
names=names, logger=logger, domainsid=domainsid,
schema=schema, hostname=hostname, ldapadminpass=ldapadminpass,
slapd_path=slapd_path,
share_ldb.load_ldif_file_add(setup_path("share.ldif"))
logger.info("Setting up secrets.ldb")
- secrets_ldb = setup_secretsdb(paths, setup_path,
+ secrets_ldb = setup_secretsdb(paths,
session_info=session_info,
backend_credentials=provision_backend.secrets_credentials, lp=lp)
try:
logger.info("Setting up the registry")
- setup_registry(paths.hklm, setup_path, session_info,
+ setup_registry(paths.hklm, session_info,
lp=lp)
logger.info("Setting up the privileges database")
- setup_privileges(paths.privilege, setup_path, session_info, lp=lp)
+ setup_privileges(paths.privilege, session_info, lp=lp)
logger.info("Setting up idmap db")
- idmap = setup_idmapdb(paths.idmapdb, setup_path,
+ idmap = setup_idmapdb(paths.idmapdb,
session_info=session_info, lp=lp)
logger.info("Setting up SAM db")
- samdb = setup_samdb(paths.samdb, setup_path, session_info,
+ samdb = setup_samdb(paths.samdb, session_info,
provision_backend, lp, names, logger=logger,
domainsid=domainsid, schema=schema, domainguid=domainguid,
policyguid=policyguid, policyguid_dc=policyguid_dc,
raise
if serverrole == "domain controller":
- secretsdb_setup_dns(secrets_ldb, setup_path, names,
+ secretsdb_setup_dns(secrets_ldb, names,
paths.private_dir, realm=names.realm,
dnsdomain=names.dnsdomain,
dns_keytab_path=paths.dns_keytab, dnspass=dnspass)
# Only make a zone file on the first DC, it should be
# replicated with DNS replication
- create_zone_file(lp, logger, paths, targetdir, setup_path,
+ create_zone_file(lp, logger, paths, targetdir,
dnsdomain=names.dnsdomain, hostip=hostip, hostip6=hostip6,
hostname=names.hostname, realm=names.realm,
domainguid=domainguid, ntdsguid=names.ntdsguid)
- create_named_conf(paths, setup_path, realm=names.realm,
+ create_named_conf(paths, realm=names.realm,
dnsdomain=names.dnsdomain, private_dir=paths.private_dir)
- create_named_txt(paths.namedtxt, setup_path,
+ create_named_txt(paths.namedtxt,
realm=names.realm, dnsdomain=names.dnsdomain,
private_dir=paths.private_dir,
keytab_name=paths.dns_keytab)
else:
set_provision_usn(samdb, 0, maxUSN)
- create_krb5_conf(paths.krb5conf, setup_path,
+ create_krb5_conf(paths.krb5conf,
dnsdomain=names.dnsdomain, hostname=names.hostname,
realm=names.realm)
logger.info("A Kerberos configuration suitable for Samba 4 has been "
"generated at %s", paths.krb5conf)
if serverrole == "domain controller":
- create_dns_update_list(lp, logger, paths, setup_path)
+ create_dns_update_list(lp, logger, paths)
provision_backend.post_setup()
provision_backend.shutdown()
- create_phpldapadmin_config(paths.phpldapadminconfig, setup_path,
+ create_phpldapadmin_config(paths.phpldapadminconfig,
ldapi_url)
except Exception:
secrets_ldb.transaction_cancel()
return result
-def provision_become_dc(setup_dir=None, smbconf=None, targetdir=None,
+def provision_become_dc(smbconf=None, targetdir=None,
realm=None, rootdn=None, domaindn=None, schemadn=None, configdn=None,
serverdn=None, domain=None, hostname=None, domainsid=None,
adminpass=None, krbtgtpass=None, domainguid=None, policyguid=None,
logger = logging.getLogger("provision")
samba.set_debug_level(debuglevel)
- res = provision(setup_dir, logger, system_session(), None,
+ res = provision(logger, system_session(), None,
smbconf=smbconf, targetdir=targetdir, samdb_fill=FILL_DRS,
realm=realm, rootdn=rootdn, domaindn=domaindn, schemadn=schemadn,
configdn=configdn, serverdn=serverdn, domain=domain,
return res
-def create_phpldapadmin_config(path, setup_path, ldapi_uri):
+def create_phpldapadmin_config(path, ldapi_uri):
"""Create a PHP LDAP admin configuration file.
:param path: Path to write the configuration to.
- :param setup_path: Function to generate setup paths.
"""
setup_file(setup_path("phpldapadmin-config.php"), path,
{"S4_LDAPI_URI": ldapi_uri})
-def create_zone_file(lp, logger, paths, targetdir, setup_path, dnsdomain,
+def create_zone_file(lp, logger, paths, targetdir, dnsdomain,
hostip, hostip6, hostname, realm, domainguid,
ntdsguid):
"""Write out a DNS zone file, from the info in the current database.
:param paths: paths object
- :param setup_path: Setup path function.
:param dnsdomain: DNS Domain name
:param domaindn: DN of the Domain
:param hostip: Local IPv4 IP
os.system(rndc + " unfreeze " + lp.get("realm"))
-def create_dns_update_list(lp, logger, paths, setup_path):
+def create_dns_update_list(lp, logger, paths):
"""Write out a dns_update_list file"""
# note that we use no variable substitution on this file
# the substitution is done at runtime by samba_dnsupdate
setup_file(setup_path("spn_update_list"), paths.spn_update_list, None)
-def create_named_conf(paths, setup_path, realm, dnsdomain,
+def create_named_conf(paths, realm, dnsdomain,
private_dir):
"""Write out a file containing zone statements suitable for inclusion in a
named.conf file (including GSS-TSIG configuration).
:param paths: all paths
- :param setup_path: Setup path function.
:param realm: Realm name
:param dnsdomain: DNS Domain name
:param private_dir: Path to private directory
setup_file(setup_path("named.conf.update"), paths.namedconf_update)
-def create_named_txt(path, setup_path, realm, dnsdomain, private_dir,
+def create_named_txt(path, realm, dnsdomain, private_dir,
keytab_name):
"""Write out a file containing zone statements suitable for inclusion in a
named.conf file (including GSS-TSIG configuration).
:param path: Path of the new named.conf file.
- :param setup_path: Setup path function.
:param realm: Realm name
:param dnsdomain: DNS Domain name
:param private_dir: Path to private directory
})
-def create_krb5_conf(path, setup_path, dnsdomain, hostname, realm):
+def create_krb5_conf(path, dnsdomain, hostname, realm):
"""Write out a file containing zone statements suitable for inclusion in a
named.conf file (including GSS-TSIG configuration).
:param path: Path of the new named.conf file.
- :param setup_path: Setup path function.
:param dnsdomain: DNS Domain name
:param hostname: Local hostname
:param realm: Realm name
from samba.credentials import Credentials, DONT_USE_KERBEROS
from samba.schema import Schema
-
class SlapdAlreadyRunning(Exception):
def __init__(self, uri):
class ProvisionBackend(object):
-
- def __init__(self, backend_type, paths=None, setup_path=None, lp=None,
+ def __init__(self, backend_type, paths=None, lp=None,
credentials=None, names=None, logger=None):
"""Provision a backend for samba4"""
self.paths = paths
- self.setup_path = setup_path
self.lp = lp
self.credentials = credentials
self.names = names
class ExistingBackend(ProvisionBackend):
- def __init__(self, backend_type, paths=None, setup_path=None, lp=None,
+ def __init__(self, backend_type, paths=None, lp=None,
credentials=None, names=None, logger=None, ldapi_uri=None):
super(ExistingBackend, self).__init__(backend_type=backend_type,
- paths=paths, setup_path=setup_path, lp=lp,
+ paths=paths, lp=lp,
credentials=credentials, names=names, logger=logger,
ldap_backend_forced_uri=ldapi_uri)
class LDAPBackend(ProvisionBackend):
- def __init__(self, backend_type, paths=None, setup_path=None, lp=None,
+ def __init__(self, backend_type, paths=None, lp=None,
credentials=None, names=None, logger=None, domainsid=None,
schema=None, hostname=None, ldapadminpass=None,
slapd_path=None, ldap_backend_extra_port=None,
ldap_backend_forced_uri=None, ldap_dryrun_mode=False):
super(LDAPBackend, self).__init__(backend_type=backend_type,
- paths=paths, setup_path=setup_path, lp=lp,
+ paths=paths, lp=lp,
credentials=credentials, names=names, logger=logger)
self.domainsid = domainsid
class OpenLDAPBackend(LDAPBackend):
- def __init__(self, backend_type, paths=None, setup_path=None, lp=None,
+ def __init__(self, backend_type, paths=None, lp=None,
credentials=None, names=None, logger=None, domainsid=None,
schema=None, hostname=None, ldapadminpass=None, slapd_path=None,
ldap_backend_extra_port=None, ldap_dryrun_mode=False,
ol_mmr_urls=None, nosync=False, ldap_backend_forced_uri=None):
+ from samba.provision import setup_path
super(OpenLDAPBackend, self).__init__( backend_type=backend_type,
- paths=paths, setup_path=setup_path, lp=lp,
+ paths=paths, lp=lp,
credentials=credentials, names=names, logger=logger,
domainsid=domainsid, schema=schema, hostname=hostname,
ldapadminpass=ldapadminpass, slapd_path=slapd_path,
self.olcdir = os.path.join(self.ldapdir, "slapd.d")
self.olcseedldif = os.path.join(self.ldapdir, "olc_seed.ldif")
- self.schema = Schema(self.setup_path, self.domainsid,
- schemadn=self.names.schemadn, files=[
+ self.schema = Schema(self.domainsid,
+ schemadn=self.names.schemadn, files=[
setup_path("schema_samba4.ldif")])
def setup_db_config(self, dbdir):
"""Setup a Berkeley database.
- :param setup_path: Setup path function.
:param dbdir: Database directory.
"""
+ from samba.provision import setup_path
if not os.path.isdir(os.path.join(dbdir, "bdb-logs")):
os.makedirs(os.path.join(dbdir, "bdb-logs"), 0700)
if not os.path.isdir(os.path.join(dbdir, "tmp")):
os.makedirs(os.path.join(dbdir, "tmp"), 0700)
- setup_file(self.setup_path("DB_CONFIG"),
+ setup_file(setup_path("DB_CONFIG"),
os.path.join(dbdir, "DB_CONFIG"), {"LDAPDBDIR": dbdir})
def provision(self):
- from samba.provision import ProvisioningError
+ from samba.provision import ProvisioningError, setup_path
# Wipe the directories so we can start
shutil.rmtree(os.path.join(self.ldapdir, "db"), True)
refint_attributes = refint_attributes + " " + att
memberof_config += read_and_sub_file(
- self.setup_path("memberof.conf"), {
+ setup_path("memberof.conf"), {
"MEMBER_ATTR": att,
"MEMBEROF_ATTR" : lnkattr[att] })
- refint_config = read_and_sub_file(self.setup_path("refint.conf"),
+ refint_config = read_and_sub_file(setup_path("refint.conf"),
{ "LINK_ATTRS" : refint_attributes})
attrs = ["linkID", "lDAPDisplayName"]
for url in url_list:
serverid = serverid + 1
mmr_serverids_config += read_and_sub_file(
- self.setup_path("mmr_serverids.conf"), {
+ setup_path("mmr_serverids.conf"), {
"SERVERID": str(serverid),
"LDAPSERVER": url })
rid = serverid * 10
rid = rid + 1
mmr_syncrepl_schema_config += read_and_sub_file(
- self.setup_path("mmr_syncrepl.conf"), {
+ setup_path("mmr_syncrepl.conf"), {
"RID" : str(rid),
"MMRDN": self.names.schemadn,
"LDAPSERVER" : url,
rid = rid + 1
mmr_syncrepl_config_config += read_and_sub_file(
- self.setup_path("mmr_syncrepl.conf"), {
+ setup_path("mmr_syncrepl.conf"), {
"RID" : str(rid),
"MMRDN": self.names.configdn,
"LDAPSERVER" : url,
rid = rid + 1
mmr_syncrepl_user_config += read_and_sub_file(
- self.setup_path("mmr_syncrepl.conf"), {
+ setup_path("mmr_syncrepl.conf"), {
"RID" : str(rid),
"MMRDN": self.names.domaindn,
"LDAPSERVER" : url,
olc_serverids_config = ""
olc_syncrepl_seed_config = ""
olc_mmr_config += read_and_sub_file(
- self.setup_path("olc_mmr.conf"), {})
+ setup_path("olc_mmr.conf"), {})
rid = 500
for url in url_list:
serverid = serverid + 1
olc_serverids_config += read_and_sub_file(
- self.setup_path("olc_serverid.conf"), {
+ setup_path("olc_serverid.conf"), {
"SERVERID" : str(serverid), "LDAPSERVER" : url })
rid = rid + 1
olc_syncrepl_config += read_and_sub_file(
- self.setup_path("olc_syncrepl.conf"), {
+ setup_path("olc_syncrepl.conf"), {
"RID" : str(rid), "LDAPSERVER" : url,
"MMR_PASSWORD": mmr_pass})
olc_syncrepl_seed_config += read_and_sub_file(
- self.setup_path("olc_syncrepl_seed.conf"), {
+ setup_path("olc_syncrepl_seed.conf"), {
"RID" : str(rid), "LDAPSERVER" : url})
- setup_file(self.setup_path("olc_seed.ldif"), self.olcseedldif,
+ setup_file(setup_path("olc_seed.ldif"), self.olcseedldif,
{"OLC_SERVER_ID_CONF": olc_serverids_config,
"OLC_PW": self.ldapadminpass,
"OLC_SYNCREPL_CONF": olc_syncrepl_seed_config})
# end olc
- setup_file(self.setup_path("slapd.conf"), self.slapdconf,
+ setup_file(setup_path("slapd.conf"), self.slapdconf,
{"DNSDOMAIN": self.names.dnsdomain,
"LDAPDIR": self.ldapdir,
"DOMAINDN": self.names.domaindn,
if not os.path.exists(os.path.join(self.ldapdir, "db", "samba", "cn=samba")):
os.makedirs(os.path.join(self.ldapdir, "db", "samba", "cn=samba"), 0700)
- setup_file(self.setup_path("cn=samba.ldif"),
+ setup_file(setup_path("cn=samba.ldif"),
os.path.join(self.ldapdir, "db", "samba", "cn=samba.ldif"),
{ "UUID": str(uuid.uuid4()),
"LDAPTIME": timestring(int(time.time()))} )
- setup_file(self.setup_path("cn=samba-admin.ldif"),
+ setup_file(setup_path("cn=samba-admin.ldif"),
os.path.join(self.ldapdir, "db", "samba", "cn=samba", "cn=samba-admin.ldif"),
{"LDAPADMINPASS_B64": b64encode(self.ldapadminpass),
"UUID": str(uuid.uuid4()),
"LDAPTIME": timestring(int(time.time()))} )
if self.ol_mmr_urls is not None:
- setup_file(self.setup_path("cn=replicator.ldif"),
+ setup_file(setup_path("cn=replicator.ldif"),
os.path.join(self.ldapdir, "db", "samba", "cn=samba", "cn=replicator.ldif"),
{"MMR_PASSWORD_B64": b64encode(mmr_pass),
"UUID": str(uuid.uuid4()),
mapping = "schema-map-openldap-2.3"
backend_schema = "backend-schema.schema"
- f = open(self.setup_path(mapping), 'r')
+ f = open(setup_path(mapping), 'r')
backend_schema_data = self.schema.convert_to_openldap(
"openldap", f.read())
assert backend_schema_data is not None
class FDSBackend(LDAPBackend):
- def __init__(self, backend_type, paths=None, setup_path=None, lp=None,
+ def __init__(self, backend_type, paths=None, lp=None,
credentials=None, names=None, logger=None, domainsid=None,
schema=None, hostname=None, ldapadminpass=None, slapd_path=None,
ldap_backend_extra_port=None, ldap_dryrun_mode=False, root=None,
setup_ds_path=None):
super(FDSBackend, self).__init__(backend_type=backend_type,
- paths=paths, setup_path=setup_path, lp=lp,
+ paths=paths, lp=lp,
credentials=credentials, names=names, logger=logger,
domainsid=domainsid, schema=schema, hostname=hostname,
ldapadminpass=ldapadminpass, slapd_path=slapd_path,
self.index_ldif = os.path.join(self.ldapdir, "fedorads-index.ldif")
self.samba_ldif = os.path.join(self.ldapdir, "fedorads-samba.ldif")
- self.samba3_schema = self.setup_path(
+ self.samba3_schema = setup_path(
"../../examples/LDAP/samba.schema")
self.samba3_ldif = os.path.join(self.ldapdir, "samba3.ldif")
raise Exception("Unable to convert Samba 3 schema.")
self.schema = Schema(
- self.setup_path,
self.domainsid,
schemadn=self.names.schemadn,
files=[setup_path("schema_samba4.ldif"), self.samba3_ldif],
"1001:1.3.6.1.4.1.7165.2.2"])
def provision(self):
- from samba.provision import ProvisioningError
+ from samba.provision import ProvisioningError, setup_path
if self.ldap_backend_extra_port is not None:
serverport = "ServerPort=%d" % self.ldap_backend_extra_port
else:
serverport = ""
- setup_file(self.setup_path("fedorads.inf"), self.fedoradsinf,
+ setup_file(setup_path("fedorads.inf"), self.fedoradsinf,
{"ROOT": self.root,
"HOSTNAME": self.hostname,
"DNSDOMAIN": self.names.dnsdomain,
"LDAPMANAGERPASS": self.ldapadminpass,
"SERVERPORT": serverport})
- setup_file(self.setup_path("fedorads-partitions.ldif"),
+ setup_file(setup_path("fedorads-partitions.ldif"),
self.partitions_ldif,
{"CONFIGDN": self.names.configdn,
"SCHEMADN": self.names.schemadn,
"SAMBADN": self.sambadn,
})
- setup_file(self.setup_path("fedorads-sasl.ldif"), self.sasl_ldif,
+ setup_file(setup_path("fedorads-sasl.ldif"), self.sasl_ldif,
{"SAMBADN": self.sambadn,
})
- setup_file(self.setup_path("fedorads-dna.ldif"), self.dna_ldif,
+ setup_file(setup_path("fedorads-dna.ldif"), self.dna_ldif,
{"DOMAINDN": self.names.domaindn,
"SAMBADN": self.sambadn,
"DOMAINSID": str(self.domainsid),
})
- setup_file(self.setup_path("fedorads-pam.ldif"), self.pam_ldif)
+ setup_file(setup_path("fedorads-pam.ldif"), self.pam_ldif)
lnkattr = self.schema.linked_attributes()
- refint_config = open(self.setup_path("fedorads-refint-delete.ldif"), 'r').read()
+ refint_config = open(setup_path("fedorads-refint-delete.ldif"), 'r').read()
memberof_config = ""
index_config = ""
argnum = 3
for attr in lnkattr.keys():
if lnkattr[attr] is not None:
refint_config += read_and_sub_file(
- self.setup_path("fedorads-refint-add.ldif"),
+ setup_path("fedorads-refint-add.ldif"),
{ "ARG_NUMBER" : str(argnum),
"LINK_ATTR" : attr })
memberof_config += read_and_sub_file(
- self.setup_path("fedorads-linked-attributes.ldif"),
+ setup_path("fedorads-linked-attributes.ldif"),
{ "MEMBER_ATTR" : attr,
"MEMBEROF_ATTR" : lnkattr[attr] })
index_config += read_and_sub_file(
- self.setup_path("fedorads-index.ldif"), { "ATTR" : attr })
+ setup_path("fedorads-index.ldif"), { "ATTR" : attr })
argnum += 1
open(self.refint_ldif, 'w').write(refint_config)
attr = "nsUniqueId"
index_config += read_and_sub_file(
- self.setup_path("fedorads-index.ldif"), { "ATTR" : attr })
+ setup_path("fedorads-index.ldif"), { "ATTR" : attr })
open(self.index_ldif, 'w').write(index_config)
- setup_file(self.setup_path("fedorads-samba.ldif"), self.samba_ldif, {
+ setup_file(setup_path("fedorads-samba.ldif"), self.samba_ldif, {
"SAMBADN": self.sambadn,
"LDAPADMINPASS": self.ldapadminpass
})
# Build a schema file in Fedora DS format
backend_schema_data = self.schema.convert_to_openldap("fedora-ds",
- open(self.setup_path(mapping), 'r').read())
+ open(setup_path(mapping), 'r').read())
assert backend_schema_data is not None
f = open(os.path.join(self.ldapdir, backend_schema), 'w')
try:
class Schema(object):
- def __init__(self, setup_path, domain_sid, invocationid=None, schemadn=None,
+ def __init__(self, domain_sid, invocationid=None, schemadn=None,
files=None, override_prefixmap=None, additional_prefixmap=None):
+ from samba.provision import setup_path
+
"""Load schema for the SamDB from the AD schema files and
samba4_schema.ldif
:param samdb: Load a schema into a SamDB.
- :param setup_path: Setup path function.
:param schemadn: DN of the schema
Returns the schema data loaded, to avoid double-parsing when then
return attributes
-def ldb_with_schema(setup_dir=None,
- schemadn="cn=schema,cn=configuration,dc=example,dc=com",
- domainsid=None,
- override_prefixmap=None):
+def ldb_with_schema(schemadn="cn=schema,cn=configuration,dc=example,dc=com",
+ domainsid=None,
+ override_prefixmap=None):
"""Load schema for the SamDB from the AD schema files and samba4_schema.ldif
- :param setup_dir: Setup path
:param schemadn: DN of the schema
:param serverdn: DN of the server
operate without a remote or local schema.
"""
- def setup_path(file):
- return os.path.join(setup_dir, file)
-
if domainsid is None:
domainsid = security.random_sid()
else:
domainsid = security.dom_sid(domainsid)
- return Schema(setup_path, domainsid, schemadn=schemadn,
+ return Schema(domainsid, schemadn=schemadn,
override_prefixmap=override_prefixmap)
"""Tests for samba.provision."""
import os
-from samba.provision import setup_secretsdb, findnss, ProvisionPaths, find_setup_dir
+from samba.provision import setup_secretsdb, findnss, ProvisionPaths
import samba.tests
from samba.tests import env_loadparm, TestCase
-setup_dir = find_setup_dir()
-def setup_path(file):
- return os.path.join(setup_dir, file)
-
-
def create_dummy_secretsdb(path, lp=None):
"""Create a dummy secrets database for use in tests.
paths.private_dir = os.path.dirname(path)
paths.keytab = "no.keytab"
paths.dns_keytab = "no.dns.keytab"
- secrets_ldb = setup_secretsdb(paths, setup_path, None, None, lp=lp)
+ secrets_ldb = setup_secretsdb(paths, None, None, lp=lp)
secrets_ldb.transaction_commit()
return secrets_ldb
paths.private_dir = os.path.dirname(path)
paths.keytab = "no.keytab"
paths.dns_keytab = "no.dns.keytab"
- ldb = setup_secretsdb(paths, setup_path, None, None, lp=env_loadparm())
+ ldb = setup_secretsdb(paths, None, None, lp=env_loadparm())
try:
self.assertEquals("LSA Secrets",
ldb.searchone(basedn="CN=LSA Secrets", attribute="CN"))
from samba.auth import system_session
from samba.provision import (setup_samdb, guess_names, make_smbconf,
- find_setup_dir, provision_paths_from_lp)
+ provision_paths_from_lp)
from samba.provision import DEFAULT_POLICY_GUID, DEFAULT_DC_POLICY_GUID
from samba.provision.backend import ProvisionBackend
from samba.tests import TestCaseInTempDir
provisioning tests (which need a Sam).
"""
- def setup_path(self, relpath):
- return os.path.join(find_setup_dir(), relpath)
-
def setUp(self):
super(SamDBTestCase, self).setUp()
invocationid = str(uuid.uuid4())
policyguid_dc = DEFAULT_DC_POLICY_GUID
smbconf = os.path.join(self.tempdir, "smb.conf")
- make_smbconf(smbconf, self.setup_path, hostname, domain, dnsdomain,
+ make_smbconf(smbconf, hostname, domain, dnsdomain,
serverrole, self.tempdir)
self.lp = param.LoadParm()
logger = logging.getLogger("provision")
provision_backend = ProvisionBackend("ldb", paths=paths,
- setup_path=self.setup_path, lp=self.lp, credentials=None,
+ lp=self.lp, credentials=None,
names=names, logger=logger)
- schema = Schema(self.setup_path, domainsid, invocationid=invocationid,
+ schema = Schema(domainsid, invocationid=invocationid,
schemadn=names.schemadn, serverdn=names.serverdn,
am_rodc=False)
- self.samdb = setup_samdb(path, self.setup_path, session_info,
+ self.samdb = setup_samdb(path, session_info,
provision_backend, self.lp, names, logger,
domainsid, domainguid, policyguid, policyguid_dc, False,
"secret", "secret", "secret", invocationid, "secret",
key_handle.set_value(value_name, value_type, value_data)
-def upgrade_provision(samba3, setup_dir, logger, credentials, session_info,
+def upgrade_provision(samba3, logger, credentials, session_info,
smbconf, targetdir):
oldconf = samba3.get_conf()
else:
machinepass = None
- result = provision(setup_dir=setup_dir, logger=logger,
+ result = provision(logger=logger,
session_info=session_info, credentials=credentials,
targetdir=targetdir, realm=realm, domain=domainname,
domainguid=domainguid, domainsid=domainsid,
return names
-def newprovision(names, setup_dir, creds, session, smbconf, provdir, logger):
+def newprovision(names, creds, session, smbconf, provdir, logger):
"""Create a new provision.
This provision will be the reference for knowing what has changed in the
since the latest upgrade in the current provision
:param names: List of provision parameters
- :param setup_dir: Directory where the setup files are stored
:param creds: Credentials for the authentification
:param session: Session object
:param smbconf: Path to the smb.conf file
shutil.rmtree(provdir)
os.mkdir(provdir)
logger.info("Provision stored in %s", provdir)
- provision(setup_dir, logger, session, creds, smbconf=smbconf,
+ provision(logger, session, creds, smbconf=smbconf,
targetdir=provdir, samdb_fill=FILL_FULL, realm=names.realm,
domain=names.domain, domainguid=names.domainguid,
domainsid=str(names.domainsid), ntdsguid=names.ntdsguid,
from samba.credentials import DONT_USE_KERBEROS
from samba.auth import system_session
import samba.getopt as options
-from samba.provision import provision, FILL_FULL, FILL_NT4SYNC, FILL_DRS, find_setup_dir, ProvisioningError
+from samba.provision import provision, FILL_FULL, FILL_NT4SYNC, FILL_DRS, ProvisioningError
from samba.dsdb import (
DS_DOMAIN_FUNCTION_2000,
DS_DOMAIN_FUNCTION_2003,
credopts = options.CredentialsOptions(parser)
parser.add_option_group(credopts)
parser.add_option("--interactive", help="Ask for names", action="store_true")
-parser.add_option("--setupdir", type="string", metavar="DIR",
- help="directory with setup files")
parser.add_option("--domain", type="string", metavar="DOMAIN",
help="set domain")
parser.add_option("--domain-guid", type="string", metavar="GUID",
creds.set_kerberos_state(DONT_USE_KERBEROS)
-setup_dir = opts.setupdir
-if setup_dir is None:
- setup_dir = find_setup_dir()
-
samdb_fill = FILL_FULL
if opts.blank:
samdb_fill = FILL_NT4SYNC
session = system_session()
try:
- provision(setup_dir, logger,
+ provision(logger,
session, creds, smbconf=smbconf, targetdir=opts.targetdir,
samdb_fill=samdb_fill, realm=opts.realm, domain=opts.domain,
domainguid=opts.domain_guid, domainsid=opts.domain_sid,
import samba
import samba.getopt as options
from samba.auth import system_session
-from samba.provision import find_setup_dir
from samba.upgrade import upgrade_provision
from samba.samba3 import Samba3
-
parser = optparse.OptionParser("upgrade_from_s3 [options] <libdir> <smbconf>")
sambaopts = options.SambaOptions(parser)
parser.add_option_group(sambaopts)
parser.add_option_group(options.VersionOptions(parser))
credopts = options.CredentialsOptions(parser)
parser.add_option_group(credopts)
-parser.add_option("--setupdir", type="string", metavar="DIR",
- help="directory with setup files")
parser.add_option("--quiet", help="Be quiet")
parser.add_option("--blank",
help="do not add users or groups, just the structure")
logger.info("Provisioning")
-setup_dir = opts.setupdir
-if setup_dir is None:
- setup_dir = find_setup_dir()
-
lp = sambaopts.get_loadparm()
smbconf = lp.configfile
creds = credopts.get_credentials(lp)
-upgrade_provision(samba3, setup_dir, logger, credentials=creds,
+upgrade_provision(samba3, logger, credentials=creds,
session_info=system_session(), smbconf=smbconf,
targetdir=opts.targetdir)
git.samba.org / samba.git / commitdiff