mirror of
https://github.com/samba-team/samba.git
synced 2025-02-08 05:57:51 +03:00
1eb5d2e4fc
If the directory is always cleaned up then it is not possible to look at daemon logs to debug test failures. This target is only really used by autobuild.py, which (optionally) cleans up the parent directory anyway. BUG: https://bugzilla.samba.org/show_bug.cgi?id=13924 Signed-off-by: Martin Schwenke <martin@meltin.net> Reviewed-by: Amitay Isaacs <amitay@gmail.com> Autobuild-User(master): Amitay Isaacs <amitay@samba.org> Autobuild-Date(master): Tue May 7 06:56:01 UTC 2019 on sn-devel-184 (cherry picked from commit 5a9e338330fe136908a3a17a5df81c054c5cc5b0)
1212 lines
48 KiB
Python
1212 lines
48 KiB
Python
#!/usr/bin/env python
|
|
|
|
APPNAME = 'ctdb'
|
|
|
|
blddir = 'bin'
|
|
|
|
import sys, os
|
|
|
|
# find the buildtools directory
|
|
srcdir = '.'
|
|
while not os.path.exists(srcdir+'/buildtools') and len(srcdir.split('/')) < 5:
|
|
srcdir = srcdir + '/..'
|
|
sys.path.insert(0, srcdir + '/buildtools/wafsamba')
|
|
|
|
import wafsamba, samba_dist, Options, Logs, Utils
|
|
import samba_utils, samba_version
|
|
|
|
env = samba_utils.LOAD_ENVIRONMENT()
|
|
if os.path.isfile('./VERSION'):
|
|
vdir = '.'
|
|
elif os.path.isfile('../VERSION'):
|
|
vdir = '..'
|
|
else:
|
|
Logs.error("VERSION file not found")
|
|
|
|
version = samba_version.samba_version_file('%s/VERSION' % vdir, vdir, env)
|
|
VERSION = version.STRING.replace('-', '.')
|
|
|
|
default_prefix = Options.default_prefix = '/usr/local'
|
|
|
|
samba_dist.DIST_DIRS('''ctdb:. lib/replace:lib/replace lib/talloc:lib/talloc
|
|
lib/tevent:lib/tevent lib/tdb:lib/tdb
|
|
third_party/socket_wrapper:third_party/socket_wrapper
|
|
third_party/popt:third_party/popt
|
|
lib/util:lib/util lib/tdb_wrap:lib/tdb_wrap
|
|
lib/ccan:lib/ccan libcli/util:libcli/util
|
|
lib/async_req:lib/async_req
|
|
buildtools:buildtools third_party/waf:third_party/waf''')
|
|
|
|
manpages_binary = [
|
|
'ctdb.1',
|
|
'ctdbd.1',
|
|
'ltdbtool.1',
|
|
'ping_pong.1'
|
|
]
|
|
|
|
manpages_misc = [
|
|
'ctdb_diagnostics.1',
|
|
'ctdbd_wrapper.1',
|
|
'onnode.1',
|
|
'ctdb.conf.5',
|
|
'ctdb-script.options.5',
|
|
'ctdb.sysconfig.5',
|
|
'ctdb.7',
|
|
'ctdb-statistics.7',
|
|
'ctdb-tunables.7',
|
|
]
|
|
|
|
manpages_etcd = [
|
|
'ctdb-etcd.7',
|
|
]
|
|
|
|
manpages_ceph = [
|
|
'ctdb_mutex_ceph_rados_helper.7',
|
|
]
|
|
|
|
|
|
def set_options(opt):
|
|
opt.PRIVATE_EXTENSION_DEFAULT('ctdb')
|
|
|
|
opt.RECURSE('lib/replace')
|
|
|
|
opt.RECURSE('lib/util')
|
|
|
|
opt.RECURSE('lib/talloc')
|
|
opt.RECURSE('lib/tevent')
|
|
opt.RECURSE('lib/tdb')
|
|
|
|
opt.add_option('--enable-infiniband',
|
|
help=("Turn on infiniband support (default=no)"),
|
|
action="store_true", dest='ctdb_infiniband', default=False)
|
|
opt.add_option('--enable-pmda',
|
|
help=("Turn on PCP pmda support (default=no)"),
|
|
action="store_true", dest='ctdb_pmda', default=False)
|
|
opt.add_option('--enable-etcd-reclock',
|
|
help=("Enable etcd recovery lock helper (default=no)"),
|
|
action="store_true", dest='ctdb_etcd_reclock', default=False)
|
|
|
|
opt.add_option('--with-libcephfs',
|
|
help=("Directory under which libcephfs is installed"),
|
|
action="store", dest='libcephfs_dir', default=None)
|
|
opt.add_option('--enable-ceph-reclock',
|
|
help=("Enable Ceph CTDB recovery lock helper (default=no)"),
|
|
action="store_true", dest='ctdb_ceph_reclock', default=False)
|
|
|
|
opt.add_option('--with-logdir',
|
|
help=("Path to log directory"),
|
|
action="store", dest='ctdb_logdir', default=None)
|
|
opt.add_option('--with-socketpath',
|
|
help=("path to CTDB daemon socket"),
|
|
action="store", dest='ctdb_sockpath', default=None)
|
|
|
|
|
|
def configure(conf):
|
|
|
|
# No need to build python bindings for talloc/tevent/tdb
|
|
if conf.IN_LAUNCH_DIR():
|
|
conf.env.standalone_ctdb = True
|
|
Options.options.disable_python = True
|
|
|
|
conf.RECURSE('lib/replace')
|
|
|
|
conf.CHECK_HEADERS(headers='''sys/socket.h
|
|
netinet/in.h
|
|
netinet/if_ether.h
|
|
netinet/ip.h
|
|
netinet/ip6.h
|
|
netinet/icmp6.h''',
|
|
together=True)
|
|
|
|
conf.CHECK_CODE('int s = socket(AF_PACKET, SOCK_RAW, 0);',
|
|
define='HAVE_AF_PACKET',
|
|
headers='sys/socket.h linux/if_packet.h')
|
|
|
|
conf.CHECK_CODE('struct sockaddr_ll sall; sall.sll_family = AF_PACKET;',
|
|
define='HAVE_PACKETSOCKET',
|
|
headers='sys/socket.h linux/if_packet.h')
|
|
|
|
if conf.env.standalone_ctdb:
|
|
conf.SAMBA_CHECK_PERL(mandatory=True)
|
|
|
|
conf.SAMBA_CHECK_PYTHON(mandatory=False, version=(2,5,0))
|
|
conf.SAMBA_CHECK_PYTHON_HEADERS(mandatory=False)
|
|
|
|
if conf.CHECK_FOR_THIRD_PARTY():
|
|
conf.RECURSE('third_party/popt')
|
|
if conf.env.standalone_ctdb or conf.CONFIG_GET('ENABLE_SELFTEST'):
|
|
conf.RECURSE('third_party/socket_wrapper')
|
|
conf.env.SOCKET_WRAPPER_SO_PATH = conf.CONFIG_GET('LIBSOCKET_WRAPPER_SO_PATH')
|
|
else:
|
|
if not conf.CHECK_POPT():
|
|
raise Utils.WafError('popt development packages have not been found\nIf third_party is installed, check that it is in the proper place.')
|
|
else:
|
|
conf.define('USING_SYSTEM_POPT', 1)
|
|
conf.env.SOCKET_WRAPPER_SO_PATH = ''
|
|
|
|
|
|
if conf.env.standalone_ctdb or conf.CONFIG_GET('ENABLE_SELFTEST'):
|
|
if not conf.CHECK_SOCKET_WRAPPER():
|
|
raise Utils.WafError('socket_wrapper package has not been found.\nIf third_party is installed, check that it is in the proper place.')
|
|
else:
|
|
conf.define('USING_SYSTEM_SOCKET_WRAPPER', 1)
|
|
conf.env.SOCKET_WRAPPER_SO_PATH = conf.CONFIG_GET('LIBSOCKET_WRAPPER_SO_PATH')
|
|
|
|
conf.RECURSE('lib/util')
|
|
|
|
conf.RECURSE('lib/talloc')
|
|
conf.RECURSE('lib/tevent')
|
|
conf.RECURSE('lib/tdb')
|
|
|
|
conf.CHECK_HEADERS('sched.h')
|
|
conf.CHECK_HEADERS('procinfo.h')
|
|
if sys.platform.startswith('aix') and not conf.CHECK_FUNCS('thread_setsched'):
|
|
Logs.error('Need thread_setsched() on AIX')
|
|
sys.exit(1)
|
|
elif not conf.CHECK_FUNCS('sched_setscheduler'):
|
|
Logs.error('Need sched_setscheduler()')
|
|
sys.exit(1)
|
|
conf.CHECK_FUNCS('mlockall')
|
|
|
|
if not conf.CHECK_VARIABLE('ETIME', headers='errno.h'):
|
|
conf.DEFINE('ETIME', 'ETIMEDOUT')
|
|
|
|
if sys.platform.startswith('linux'):
|
|
conf.SET_TARGET_TYPE('pcap', 'EMPTY')
|
|
else:
|
|
if not conf.CHECK_HEADERS('pcap.h'):
|
|
Logs.error('Need libpcap')
|
|
sys.exit(1)
|
|
if not conf.CHECK_FUNCS_IN('pcap_open_live', 'pcap', headers='pcap.h'):
|
|
Logs.error('Need libpcap')
|
|
sys.exit(1)
|
|
|
|
if not conf.CHECK_FUNCS_IN('backtrace backtrace_symbols', 'execinfo',
|
|
checklibc=True, headers='execinfo.h'):
|
|
Logs.error('backtrace support not available')
|
|
|
|
have_pmda = False
|
|
if Options.options.ctdb_pmda:
|
|
pmda_support = True
|
|
|
|
if not conf.CHECK_HEADERS('pcp/pmapi.h pcp/impl.h pcp/pmda.h',
|
|
together=True):
|
|
pmda_support = False
|
|
if not conf.CHECK_FUNCS_IN('pmProgname', 'pcp'):
|
|
pmda_support = False
|
|
if not conf.CHECK_FUNCS_IN('pmdaDaemon', 'pcp_pmda'):
|
|
pmda_support = False
|
|
if pmda_support:
|
|
conf.CHECK_TYPE_IN('__pmID_int', 'pcp/pmapi.h pcp/impl.h')
|
|
have_pmda = True
|
|
else:
|
|
Logs.error("PMDA support not available")
|
|
sys.exit(1)
|
|
if have_pmda:
|
|
Logs.info('Building with PMDA support')
|
|
conf.define('HAVE_PMDA', 1)
|
|
conf.env.CTDB_PMDADIR = os.path.join(conf.env.LOCALSTATEDIR,
|
|
'lib/pcp/pmdas/ctdb')
|
|
|
|
have_infiniband = False
|
|
if Options.options.ctdb_infiniband:
|
|
ib_support = True
|
|
|
|
if not conf.CHECK_HEADERS('infiniband/verbs.h rdma/rdma_cma.h'):
|
|
ib_support = False
|
|
if not conf.CHECK_FUNCS_IN('ibv_create_qp', 'ibverbs'):
|
|
ib_support = False
|
|
if not conf.CHECK_FUNCS_IN('rdma_connect', 'rdmacm'):
|
|
ib_support = False
|
|
if ib_support:
|
|
have_infiniband = True
|
|
else:
|
|
Logs.error("Infiniband support not available")
|
|
sys.exit(1)
|
|
if have_infiniband:
|
|
Logs.info('Building with Infiniband support')
|
|
conf.define('HAVE_INFINIBAND', 1)
|
|
conf.define('USE_INFINIBAND', 1)
|
|
|
|
have_etcd_reclock = False
|
|
if Options.options.ctdb_etcd_reclock:
|
|
try:
|
|
conf.check_python_module('etcd')
|
|
have_etcd_reclock = True
|
|
except:
|
|
Logs.error('etcd support not available')
|
|
sys.exit(1)
|
|
if have_etcd_reclock:
|
|
Logs.info('Building with etcd support')
|
|
conf.env.etcd_reclock = have_etcd_reclock
|
|
|
|
if Options.options.ctdb_ceph_reclock:
|
|
# Use custom libcephfs library path if provided. XXX The top level build
|
|
# explicitly sets LIBPATH_CEPH-COMMON when libcephfs_dir isn't provided.
|
|
if Options.options.libcephfs_dir:
|
|
conf.env['CPPPATH_RADOS'] = Options.options.libcephfs_dir + '/include'
|
|
conf.env['LIBPATH_RADOS'] = Options.options.libcephfs_dir + '/lib'
|
|
conf.env['LIBPATH_CEPH-COMMON'] = conf.env['LIBPATH_RADOS'] + '/ceph'
|
|
|
|
if (conf.CHECK_HEADERS('rados/librados.h', False, False, 'rados') and
|
|
conf.CHECK_LIB('rados', shlib=True)):
|
|
conf.CHECK_LIB('ceph-common', shlib=True)
|
|
Logs.info('Building with Ceph librados recovery lock support')
|
|
conf.define('HAVE_LIBRADOS', 1)
|
|
else:
|
|
Logs.error("Missing librados for Ceph recovery lock support")
|
|
sys.exit(1)
|
|
|
|
conf.env.CTDB_BINDIR = os.path.join(conf.env.EXEC_PREFIX, 'bin')
|
|
conf.env.CTDB_DATADIR = os.path.join(conf.env.EXEC_PREFIX, 'share/ctdb')
|
|
conf.env.CTDB_ETCDIR = os.path.join(conf.env.SYSCONFDIR, 'ctdb')
|
|
conf.env.CTDB_VARDIR = os.path.join(conf.env.LOCALSTATEDIR, 'lib/ctdb')
|
|
conf.env.CTDB_RUNDIR = os.path.join(conf.env.LOCALSTATEDIR, 'run/ctdb')
|
|
conf.env.CTDB_HELPER_BINDIR = os.path.join(conf.env.LIBEXECDIR, 'ctdb')
|
|
|
|
if Options.options.ctdb_logdir:
|
|
conf.env.CTDB_LOGDIR = Options.options.ctdb_logdir
|
|
else:
|
|
conf.env.CTDB_LOGDIR = os.path.join(conf.env.LOCALSTATEDIR, 'log')
|
|
|
|
if Options.options.ctdb_sockpath:
|
|
conf.env.CTDB_SOCKPATH = Options.options.ctdb_sockpath
|
|
else:
|
|
conf.env.CTDB_SOCKPATH = os.path.join(conf.env.CTDB_RUNDIR,
|
|
'ctdbd.socket')
|
|
conf.define('CTDB_SOCKET', conf.env.CTDB_SOCKPATH)
|
|
|
|
conf.ADD_CFLAGS('''-DCTDB_HELPER_BINDIR=\"%s\"
|
|
-DLOGDIR=\"%s\"
|
|
-DCTDB_DATADIR=\"%s\"
|
|
-DCTDB_ETCDIR=\"%s\"
|
|
-DCTDB_VARDIR=\"%s\"
|
|
-DCTDB_RUNDIR=\"%s\"''' % (
|
|
conf.env.CTDB_HELPER_BINDIR,
|
|
conf.env.CTDB_LOGDIR,
|
|
conf.env.CTDB_DATADIR,
|
|
conf.env.CTDB_ETCDIR,
|
|
conf.env.CTDB_VARDIR,
|
|
conf.env.CTDB_RUNDIR))
|
|
|
|
conf.env.CTDB_TEST_DATADIR = os.path.join(conf.env.CTDB_DATADIR, 'tests')
|
|
conf.env.CTDB_TEST_LIBEXECDIR = os.path.join(conf.env.LIBEXECDIR, 'ctdb/tests')
|
|
|
|
# Allow unified compilation and separate compilation of utilities
|
|
# to find includes
|
|
if not conf.env.standalone_ctdb:
|
|
conf.ADD_EXTRA_INCLUDES('#include/public #ctdb/include #ctdb')
|
|
else:
|
|
if srcdir == '.':
|
|
# Building from tarball
|
|
conf.ADD_EXTRA_INCLUDES('#include')
|
|
else:
|
|
# Building standalone CTDB from within Samba tree
|
|
conf.ADD_EXTRA_INCLUDES('#ctdb/include')
|
|
conf.ADD_EXTRA_INCLUDES('#ctdb')
|
|
conf.ADD_EXTRA_INCLUDES('#lib #lib/replace')
|
|
|
|
conf.DEFINE('HAVE_CONFIG_H', 1, add_to_cflags=True)
|
|
conf.DEFINE('SAMBA_UTIL_CORE_ONLY', 1, add_to_cflags=True)
|
|
conf.SAMBA_CONFIG_H()
|
|
|
|
if 'XSLTPROC_MANPAGES' in conf.env and conf.env['XSLTPROC_MANPAGES']:
|
|
conf.env.ctdb_generate_manpages = True
|
|
else:
|
|
conf.env.ctdb_generate_manpages = False
|
|
|
|
Logs.info("xsltproc unavailable, checking for pre-built manpages")
|
|
conf.env.ctdb_prebuilt_manpages = []
|
|
manpages = manpages_binary + manpages_misc
|
|
if conf.env.etcd_reclock:
|
|
manpages += manpages_etcd
|
|
if conf.env.HAVE_LIBRADOS:
|
|
manpages += manpages_ceph
|
|
for m in manpages:
|
|
if os.path.exists(os.path.join("doc", m)):
|
|
Logs.info(" %s: yes" % (m))
|
|
conf.env.ctdb_prebuilt_manpages.append(m)
|
|
else:
|
|
Logs.info(" %s: no" % (m))
|
|
|
|
def gen_ctdb_version(task):
|
|
fp = file(task.outputs[0].bldpath(task.env), 'w')
|
|
fp.write('/* This file is auto-generated from waf */\n')
|
|
fp.write('#include "version.h"\n')
|
|
fp.write('\n')
|
|
fp.write('#define CTDB_VERSION_STRING "%s"\n' % VERSION)
|
|
fp.close()
|
|
|
|
|
|
def build(bld):
|
|
if bld.env.standalone_ctdb:
|
|
# enable building of public headers in the build tree
|
|
bld.env.build_public_headers = 'include/public'
|
|
|
|
if bld.env.standalone_ctdb:
|
|
bld.SAMBA_MKVERSION('version.h', '%s/VERSION' % vdir)
|
|
|
|
t = bld.SAMBA_GENERATOR('ctdb-version-header',
|
|
target='include/ctdb_version.h',
|
|
rule=gen_ctdb_version,
|
|
dep_vars=['VERSION'])
|
|
t.env.VERSION = VERSION
|
|
|
|
bld.env.PKGCONFIGDIR = '${LIBDIR}/pkgconfig'
|
|
|
|
bld.RECURSE('lib/replace')
|
|
if bld.CHECK_FOR_THIRD_PARTY():
|
|
bld.RECURSE('third_party/popt')
|
|
if bld.env.standalone_ctdb or bld.CONFIG_GET('SOCKET_WRAPPER'):
|
|
bld.RECURSE('third_party/socket_wrapper')
|
|
|
|
bld.RECURSE('lib/tdb_wrap')
|
|
bld.RECURSE('lib/util')
|
|
bld.RECURSE('lib/async_req')
|
|
|
|
bld.RECURSE('lib/talloc')
|
|
bld.RECURSE('lib/tevent')
|
|
bld.RECURSE('lib/tdb')
|
|
|
|
if bld.env.standalone_ctdb:
|
|
# If a combined build is implemented, CTDB will want to
|
|
# build against samba-util rather than samba-util-core.
|
|
# Similarly, other Samba subsystems expect samba-util. So,
|
|
# for a standalone build, just define a fake samba-util
|
|
# subsystem that pulls in samba-util-core.
|
|
bld.SAMBA_SUBSYSTEM('samba-util',
|
|
source='',
|
|
deps='samba-util-core')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-tcp',
|
|
source=bld.SUBDIR('tcp',
|
|
'tcp_connect.c tcp_init.c tcp_io.c'),
|
|
includes='include',
|
|
deps='replace tdb talloc tevent')
|
|
|
|
ib_deps = ''
|
|
if bld.env.HAVE_INFINIBAND:
|
|
bld.SAMBA_SUBSYSTEM('ctdb-ib',
|
|
source=bld.SUBDIR('ib',
|
|
'''ibwrapper.c ibw_ctdb.c
|
|
ibw_ctdb_init.c'''),
|
|
includes='include',
|
|
deps='replace talloc tevent tdb')
|
|
ib_deps = ' ctdb-ib rdmacm ibverbs'
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-system',
|
|
source=bld.SUBDIR('common',
|
|
'system_socket.c system.c'),
|
|
includes='include',
|
|
deps='replace talloc tevent tdb pcap samba-util')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-common',
|
|
source=bld.SUBDIR('common',
|
|
'''ctdb_io.c ctdb_util.c ctdb_ltdb.c
|
|
sock_io.c'''),
|
|
includes='include',
|
|
deps='''replace popt talloc tevent tdb popt ctdb-system
|
|
ctdb-protocol-util''')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-util',
|
|
source=bld.SUBDIR('common',
|
|
'''db_hash.c srvid.c reqid.c
|
|
pkt_read.c pkt_write.c comm.c
|
|
logging.c rb_tree.c tunable.c
|
|
pidfile.c run_proc.c
|
|
hash_count.c
|
|
run_event.c event_script.c
|
|
sock_client.c version.c
|
|
cmdline.c path.c conf.c line.c
|
|
'''),
|
|
deps='''samba-util sys_rw tevent-util
|
|
replace talloc tevent tdb popt''')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-logging-conf',
|
|
source='common/logging_conf.c',
|
|
deps='ctdb-util talloc')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol-basic',
|
|
source=bld.SUBDIR('protocol', 'protocol_basic.c'),
|
|
deps='talloc tdb')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol',
|
|
source=bld.SUBDIR('protocol',
|
|
'''protocol_header.c protocol_packet.c
|
|
protocol_types.c
|
|
protocol_call.c
|
|
protocol_message.c
|
|
protocol_control.c
|
|
protocol_keepalive.c
|
|
protocol_tunnel.c
|
|
protocol_client.c
|
|
protocol_debug.c
|
|
protocol_sock.c'''),
|
|
includes='include',
|
|
deps='ctdb-protocol-basic replace talloc tdb')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol-util',
|
|
source='protocol/protocol_util.c',
|
|
deps='ctdb-util replace talloc tdb')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-client',
|
|
source=bld.SUBDIR('client',
|
|
'''client_connect.c client_call.c
|
|
client_message.c client_control.c
|
|
client_message_sync.c
|
|
client_control_sync.c
|
|
client_db.c client_util.c
|
|
client_tunnel.c
|
|
'''),
|
|
includes='include',
|
|
deps='replace talloc tevent tdb tdb-wrap')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-server-util',
|
|
source=bld.SUBDIR('common',
|
|
'''sock_daemon.c'''),
|
|
deps='''samba-util ctdb-util ctdb-system tevent-util
|
|
LIBASYNC_REQ replace talloc tevent''')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-ipalloc',
|
|
source=bld.SUBDIR('server',
|
|
'''ipalloc_deterministic.c
|
|
ipalloc_nondeterministic.c
|
|
ipalloc_lcp2.c
|
|
ipalloc_common.c
|
|
ipalloc.c
|
|
'''),
|
|
includes='include',
|
|
deps='ctdb-protocol-util replace talloc tevent')
|
|
|
|
bld.SAMBA_BINARY('ctdb-path',
|
|
source='common/path_tool.c',
|
|
cflags='-DCTDB_PATH_TOOL',
|
|
deps='''ctdb-util samba-util talloc replace popt''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-cluster-conf',
|
|
source='cluster/cluster_conf.c',
|
|
deps='ctdb-util')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-database-conf',
|
|
source='database/database_conf.c',
|
|
deps='ctdb-util')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-event-conf',
|
|
source='event/event_conf.c',
|
|
deps='ctdb-util')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-failover-conf',
|
|
source='failover/failover_conf.c',
|
|
deps='ctdb-util')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-legacy-conf',
|
|
source='server/legacy_conf.c',
|
|
deps='ctdb-util')
|
|
|
|
bld.SAMBA_BINARY('ctdb-config',
|
|
source='common/conf_tool.c',
|
|
cflags='-DCTDB_CONF_TOOL',
|
|
deps='''ctdb-logging-conf
|
|
ctdb-event-conf
|
|
ctdb-cluster-conf
|
|
ctdb-database-conf
|
|
ctdb-failover-conf
|
|
ctdb-legacy-conf
|
|
ctdb-util samba-util talloc replace popt''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-event-protocol',
|
|
source=bld.SUBDIR('event',
|
|
'''event_protocol.c
|
|
event_protocol_util.c
|
|
'''),
|
|
deps='ctdb-protocol-basic')
|
|
|
|
bld.SAMBA_LIBRARY('ctdb-event-client',
|
|
source='event/event_client.c',
|
|
deps='ctdb-event-protocol ctdb-util tevent talloc',
|
|
private_library=True)
|
|
|
|
bld.SAMBA_BINARY('ctdb-eventd',
|
|
source=bld.SUBDIR('event',
|
|
'''event_cmd.c
|
|
event_config.c
|
|
event_context.c
|
|
event_daemon.c
|
|
event_request.c
|
|
'''),
|
|
deps='''ctdb-event-protocol
|
|
ctdb-event-conf ctdb-logging-conf
|
|
ctdb-server-util samba-util ctdb-util
|
|
talloc tevent replace popt''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb-event',
|
|
source='event/event_tool.c',
|
|
cflags='-DCTDB_EVENT_TOOL',
|
|
deps='''ctdb-event-client ctdb-event-protocol
|
|
ctdb-util samba-util talloc replace''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdbd',
|
|
source='server/ctdbd.c ' +
|
|
bld.SUBDIR('server',
|
|
'''ctdb_daemon.c ctdb_recoverd.c
|
|
ctdb_recover.c ctdb_freeze.c
|
|
ctdb_tunables.c ctdb_monitor.c
|
|
ctdb_server.c ctdb_control.c
|
|
ctdb_call.c ctdb_ltdb_server.c
|
|
ctdb_traverse.c eventscript.c
|
|
ctdb_takeover.c
|
|
ctdb_persistent.c ctdb_keepalive.c
|
|
ctdb_cluster_mutex.c
|
|
ctdb_logging.c
|
|
ctdb_uptime.c
|
|
ctdb_vacuum.c ctdb_banning.c
|
|
ctdb_statistics.c
|
|
ctdb_update_record.c
|
|
ctdb_lock.c ctdb_fork.c
|
|
ctdb_tunnel.c ctdb_client.c
|
|
ctdb_config.c
|
|
'''),
|
|
includes='include',
|
|
deps='''ctdb-common ctdb-system ctdb-protocol
|
|
ctdb-tcp ctdb-util replace sys_rw popt
|
|
ctdb-logging-conf
|
|
ctdb-cluster-conf
|
|
ctdb-database-conf
|
|
ctdb-event-conf
|
|
ctdb-failover-conf
|
|
ctdb-legacy-conf
|
|
ctdb-event-protocol
|
|
talloc tevent tdb-wrap tdb talloc_report''' +
|
|
ib_deps,
|
|
install_path='${SBINDIR}',
|
|
manpages='ctdbd.1')
|
|
|
|
bld.SAMBA_BINARY('ctdb',
|
|
source='tools/ctdb.c',
|
|
deps='''ctdb-client ctdb-protocol ctdb-protocol-util
|
|
ctdb-util ctdb-system samba-util sys_rw popt''',
|
|
install_path='${BINDIR}',
|
|
manpages='ctdb.1')
|
|
|
|
bld.SAMBA_BINARY('ctdb_killtcp',
|
|
source='tools/ctdb_killtcp.c',
|
|
deps='''ctdb-protocol-util ctdb-util ctdb-system
|
|
samba-util replace''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ltdbtool',
|
|
source='tools/ltdbtool.c',
|
|
includes='include',
|
|
deps='tdb',
|
|
install_path='${BINDIR}',
|
|
manpages='ltdbtool.1')
|
|
|
|
bld.SAMBA_BINARY('ctdb_lock_helper',
|
|
source='server/ctdb_lock_helper.c',
|
|
deps='''samba-util sys_rw ctdb-system tevent-util
|
|
talloc tevent tdb''',
|
|
includes='include',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb_recovery_helper',
|
|
source='server/ctdb_recovery_helper.c',
|
|
deps='''ctdb-client ctdb-protocol ctdb-util
|
|
samba-util sys_rw replace tdb''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb_takeover_helper',
|
|
source='server/ctdb_takeover_helper.c',
|
|
deps='''ctdb-client ctdb-protocol ctdb-util
|
|
samba-util sys_rw replace ctdb-ipalloc popt''',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb_mutex_fcntl_helper',
|
|
source='server/ctdb_mutex_fcntl_helper.c',
|
|
deps='sys_rw ctdb-system',
|
|
includes='include',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-smnotify-h',
|
|
source='utils/smnotify/smnotify.x',
|
|
target='utils/smnotify/smnotify.h',
|
|
rule='rpcgen -h ${SRC} > ${TGT}')
|
|
|
|
xdr_buf_hack = 'sed -e "s@^\([ \t]*register int32_t \*buf\);@\\1 = buf;@"'
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-smnotify-x',
|
|
source='utils/smnotify/smnotify.x',
|
|
target='utils/smnotify/gen_xdr.c',
|
|
rule='rpcgen -c ${SRC} | ' + xdr_buf_hack + ' > ${TGT}')
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-smnotify-c',
|
|
source='utils/smnotify/smnotify.x',
|
|
target='utils/smnotify/gen_smnotify.c',
|
|
rule='rpcgen -l ${SRC} > ${TGT}')
|
|
|
|
bld.SAMBA_BINARY('smnotify',
|
|
source=bld.SUBDIR('utils/smnotify',
|
|
'smnotify.c gen_smnotify.c gen_xdr.c'),
|
|
deps='ctdb-smnotify-h ctdb-smnotify-c ctdb-smnotify-x popt tirpc',
|
|
includes='utils utils/smnotify',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
bld.SAMBA_BINARY('ping_pong',
|
|
source='utils/ping_pong/ping_pong.c',
|
|
deps='',
|
|
install_path='${BINDIR}',
|
|
manpages='ping_pong.1')
|
|
|
|
if bld.env.HAVE_PMDA:
|
|
bld.SAMBA_BINARY('pmdactdb',
|
|
source='utils/pmda/pmda_ctdb.c',
|
|
includes='include',
|
|
deps='''ctdb-client ctdb-protocol ctdb-util
|
|
samba-util pcp_pmda pcp''',
|
|
install_path='${CTDB_PMDADIR}')
|
|
bld.INSTALL_FILES('${CTDB_PMDADIR}', 'utils/pmda/Install',
|
|
destname='Install')
|
|
bld.INSTALL_FILES('${CTDB_PMDADIR}', 'utils/pmda/Remove',
|
|
destname='Remove')
|
|
bld.INSTALL_FILES('${CTDB_PMDADIR}', 'utils/pmda/pmns',
|
|
destname='pmns')
|
|
bld.INSTALL_FILES('${CTDB_PMDADIR}', 'utils/pmda/domain.h',
|
|
destname='domain.h')
|
|
bld.INSTALL_FILES('${CTDB_PMDADIR}', 'utils/pmda/help',
|
|
destname='help')
|
|
bld.INSTALL_FILES('${CTDB_PMDADIR}', 'utils/pmda/README',
|
|
destname='README')
|
|
|
|
if bld.env.HAVE_LIBRADOS:
|
|
bld.SAMBA_BINARY('ctdb_mutex_ceph_rados_helper',
|
|
source='utils/ceph/ctdb_mutex_ceph_rados_helper.c',
|
|
deps='talloc tevent rados ceph-common',
|
|
includes='include',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
sed_expr1 = 's|/usr/local/var/lib/ctdb|%s|g' % (bld.env.CTDB_VARDIR)
|
|
sed_expr2 = 's|/usr/local/etc/ctdb|%s|g' % (bld.env.CTDB_ETCDIR)
|
|
sed_expr3 = 's|/usr/local/var/log|%s|g' % (bld.env.CTDB_LOGDIR)
|
|
sed_expr4 = 's|/usr/local/var/run/ctdb|%s|g' % (bld.env.CTDB_RUNDIR)
|
|
sed_expr5 = 's|/usr/local/sbin|%s|g' % (bld.env.SBINDIR)
|
|
sed_expr6 = 's|/usr/local/libexec/ctdb|%s|g' % (bld.env.CTDB_HELPER_BINDIR)
|
|
sed_expr7 = 's|/usr/local/bin|%s|g' % (bld.env.BINDIR)
|
|
sed_expr8 = 's|/usr/local/share/ctdb|%s|g' % (bld.env.CTDB_DATADIR)
|
|
sed_cmdline = '-e "%s" ' * 8 % \
|
|
(sed_expr1, sed_expr2, sed_expr3, sed_expr4, sed_expr5,
|
|
sed_expr6, sed_expr7, sed_expr8)
|
|
|
|
manpages_extra = manpages_misc
|
|
if bld.env.etcd_reclock:
|
|
manpages_extra += manpages_etcd
|
|
if bld.env.HAVE_LIBRADOS:
|
|
manpages_extra += manpages_ceph
|
|
for f in manpages_binary + manpages_extra:
|
|
x = '%s.xml' % (f)
|
|
bld.SAMBA_GENERATOR(x,
|
|
source=os.path.join('doc', x),
|
|
target=x,
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
|
|
if bld.env.ctdb_generate_manpages:
|
|
bld.MANPAGES(' '.join(manpages_extra), True)
|
|
else:
|
|
for m in bld.env.ctdb_prebuilt_manpages:
|
|
bld.SAMBA_GENERATOR(m,
|
|
source=os.path.join("doc", m),
|
|
target=m,
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${MANDIR}/man%s' % m[-1], m)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-onnode',
|
|
source='tools/onnode',
|
|
target='onnode',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${BINDIR}', 'onnode',
|
|
destname='onnode', chmod=0755)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-diagnostics',
|
|
source='tools/ctdb_diagnostics',
|
|
target='ctdb_diagnostics',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${BINDIR}', 'ctdb_diagnostics',
|
|
destname='ctdb_diagnostics', chmod=0755)
|
|
|
|
if bld.env.etcd_reclock:
|
|
bld.SAMBA_GENERATOR('ctdb-etcd-lock',
|
|
source='utils/etcd/ctdb_etcd_lock',
|
|
target='ctdb_etcd_lock',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${CTDB_HELPER_BINDIR}', 'ctdb_etcd_lock',
|
|
destname='ctdb_etcd_lock', chmod=0744)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-natgw',
|
|
source='tools/ctdb_natgw',
|
|
target='ctdb_natgw',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${CTDB_HELPER_BINDIR}', 'ctdb_natgw',
|
|
destname='ctdb_natgw', chmod=0755)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-lvs',
|
|
source='tools/ctdb_lvs',
|
|
target='ctdb_lvs',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${CTDB_HELPER_BINDIR}', 'ctdb_lvs',
|
|
destname='ctdb_lvs', chmod=0755)
|
|
|
|
bld.SAMBA_GENERATOR('ctdbd-wrapper',
|
|
source='config/ctdbd_wrapper',
|
|
target='ctdbd_wrapper',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${SBINDIR}', 'ctdbd_wrapper',
|
|
destname='ctdbd_wrapper', chmod=0755)
|
|
|
|
def SUBDIR_MODE_callback(arg, dirname, fnames):
|
|
for f in fnames:
|
|
fl = os.path.join(dirname, f)
|
|
if os.path.isdir(fl) or os.path.islink(fl):
|
|
continue
|
|
mode = os.lstat(fl).st_mode & 0777
|
|
if arg['trim_path']:
|
|
fl = samba_utils.os_path_relpath(fl, arg['trim_path'])
|
|
arg['file_list'].append([fl, mode])
|
|
|
|
def SUBDIR_MODE(path, trim_path=None):
|
|
pd = {'trim_path': trim_path, 'file_list': []}
|
|
os.path.walk(path, SUBDIR_MODE_callback, pd)
|
|
return pd['file_list']
|
|
|
|
event_script_subdirs = [
|
|
'events/legacy',
|
|
]
|
|
|
|
etc_subdirs = [
|
|
'nfs-checks.d'
|
|
]
|
|
|
|
if bld.env.standalone_ctdb:
|
|
configdir = 'config'
|
|
else:
|
|
configdir = 'ctdb/config'
|
|
|
|
for t in event_script_subdirs:
|
|
bld.INSTALL_DIR(os.path.join(bld.env.CTDB_ETCDIR, t))
|
|
files = SUBDIR_MODE('%s/%s' % (configdir, t), trim_path=configdir)
|
|
for fmode in files:
|
|
bld.INSTALL_FILES(bld.env.CTDB_DATADIR, 'config/%s' % fmode[0],
|
|
destname=fmode[0], chmod=fmode[1])
|
|
|
|
for t in etc_subdirs:
|
|
files = SUBDIR_MODE('%s/%s' % (configdir, t), trim_path=configdir)
|
|
for fmode in files:
|
|
bld.INSTALL_FILES(bld.env.CTDB_ETCDIR, 'config/%s' % fmode[0],
|
|
destname=fmode[0], chmod=fmode[1])
|
|
|
|
# If this is a direct install and there are no event scripts
|
|
# linked/enabled then enable some standard ones
|
|
if os.environ.get('DESTDIR') is None:
|
|
fmt = 'events/legacy/%s.script'
|
|
required_script = '00.ctdb'
|
|
required_path = os.path.join(bld.env.CTDB_ETCDIR,
|
|
fmt % (required_script))
|
|
if not os.path.islink(required_path) and \
|
|
not os.path.exists(required_path):
|
|
default_scripts = [ required_script,
|
|
'01.reclock',
|
|
'05.system',
|
|
'10.interface',
|
|
]
|
|
for t in default_scripts:
|
|
tgt = os.path.join(bld.env.CTDB_DATADIR, fmt % (t))
|
|
name = os.path.join(bld.env.CTDB_ETCDIR, fmt % (t))
|
|
bld.symlink_as(name, tgt)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-functions',
|
|
source='config/functions',
|
|
target='functions',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES(bld.env.CTDB_ETCDIR, 'functions', destname='functions')
|
|
|
|
etc_scripts = [
|
|
'ctdb-crash-cleanup.sh',
|
|
'debug-hung-script.sh',
|
|
'debug_locks.sh',
|
|
'nfs-linux-kernel-callout',
|
|
'notify.sh',
|
|
'statd-callout'
|
|
]
|
|
|
|
for t in etc_scripts:
|
|
bld.INSTALL_FILES(bld.env.CTDB_ETCDIR, 'config/%s' % t,
|
|
destname=t, chmod=0755)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-sudoers',
|
|
source='config/ctdb.sudoers',
|
|
target='ctdb.sudoers',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES('${SYSCONFDIR}/sudoers.d', 'ctdb.sudoers',
|
|
destname='ctdb')
|
|
|
|
bld.INSTALL_FILES('${CTDB_ETCDIR}/events/notification',
|
|
'config/notification.README',
|
|
destname='README')
|
|
|
|
bld.install_dir(bld.env.CTDB_LOGDIR)
|
|
bld.install_dir(bld.env.CTDB_RUNDIR)
|
|
bld.install_dir(bld.env.CTDB_VARDIR)
|
|
|
|
for d in ['volatile', 'persistent', 'state']:
|
|
bld.install_dir(os.path.join(bld.env.CTDB_VARDIR, d))
|
|
|
|
bld.SAMBA_BINARY('errcode',
|
|
source='tests/src/errcode.c',
|
|
deps='replace',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('sigcode',
|
|
source='tests/src/sigcode.c',
|
|
deps='replace',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
# Unit tests
|
|
ctdb_unit_tests = [
|
|
'db_hash_test',
|
|
'srvid_test',
|
|
'pkt_read_test',
|
|
'pkt_write_test',
|
|
'comm_test',
|
|
'comm_server_test',
|
|
'comm_client_test',
|
|
'pidfile_test',
|
|
'run_proc_test',
|
|
'sock_io_test',
|
|
'hash_count_test',
|
|
'run_event_test',
|
|
'cmdline_test',
|
|
'conf_test',
|
|
'line_test',
|
|
'event_script_test',
|
|
]
|
|
|
|
for target in ctdb_unit_tests:
|
|
src = 'tests/src/' + target + '.c'
|
|
|
|
bld.SAMBA_BINARY(target,
|
|
source=src,
|
|
deps='''talloc tevent tdb tevent-util popt
|
|
LIBASYNC_REQ samba-util sys_rw''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('reqid_test',
|
|
source='tests/src/reqid_test.c',
|
|
deps='samba-util',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('rb_test',
|
|
source='tests/src/rb_test.c',
|
|
deps='samba-util talloc',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb_packet_parse',
|
|
source='tests/src/ctdb_packet_parse.c',
|
|
deps='talloc tevent tdb ctdb-protocol',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('porting_tests',
|
|
source='tests/src/porting_tests.c',
|
|
deps='samba-util ctdb-system popt',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('sock_daemon_test',
|
|
source='tests/src/sock_daemon_test.c',
|
|
deps='''ctdb-system talloc tevent tevent-util
|
|
LIBASYNC_REQ samba-util sys_rw''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol-tests-basic',
|
|
source=bld.SUBDIR('tests/src',
|
|
'protocol_common_basic.c'),
|
|
deps='replace talloc')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol-tests-common',
|
|
source=bld.SUBDIR('tests/src',
|
|
'''protocol_common.c
|
|
protocol_common_ctdb.c
|
|
'''),
|
|
includes='include',
|
|
deps='ctdb-protocol-tests-basic replace talloc tdb')
|
|
|
|
bld.SAMBA_BINARY('protocol_basic_test',
|
|
source=bld.SUBDIR('tests/src', 'protocol_basic_test.c'),
|
|
deps='ctdb-protocol-tests-basic talloc',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
ctdb_protocol_tests = [
|
|
'protocol_types_test',
|
|
'protocol_ctdb_test',
|
|
'protocol_util_test',
|
|
'protocol_types_compat_test',
|
|
'protocol_ctdb_compat_test',
|
|
]
|
|
|
|
for target in ctdb_protocol_tests:
|
|
src = 'tests/src/' + target + '.c'
|
|
|
|
bld.SAMBA_BINARY(target,
|
|
source=src,
|
|
deps='''ctdb-protocol-tests-common
|
|
samba-util ctdb-util talloc tdb''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('event_protocol_test',
|
|
source='event/event_protocol_test.c',
|
|
deps='''ctdb-protocol-tests-basic
|
|
ctdb-protocol-basic talloc''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-tests-common',
|
|
source=bld.SUBDIR('tests/src',
|
|
'cluster_wait.c test_options.c'),
|
|
includes='include',
|
|
deps='samba-util replace popt talloc tevent tdb')
|
|
|
|
# Test binaries
|
|
ctdb_tests = [
|
|
'g_lock_loop',
|
|
'message_ring',
|
|
'fetch_ring',
|
|
'fetch_loop',
|
|
'fetch_loop_key',
|
|
'fetch_readonly',
|
|
'fetch_readonly_loop',
|
|
'transaction_loop',
|
|
'update_record',
|
|
'update_record_persistent',
|
|
'lock_tdb',
|
|
'dummy_client',
|
|
'tunnel_test',
|
|
'tunnel_cmd',
|
|
]
|
|
|
|
for target in ctdb_tests:
|
|
src = 'tests/src/' + target + '.c'
|
|
|
|
bld.SAMBA_BINARY(target,
|
|
source=src,
|
|
includes='include',
|
|
deps='''ctdb-client ctdb-protocol ctdb-util
|
|
samba-util ctdb-tests-common''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb_takeover_tests',
|
|
source='''tests/src/ctdb_takeover_tests.c
|
|
tests/src/ipalloc_read_known_ips.c''',
|
|
deps='''replace popt tdb tevent talloc ctdb-system
|
|
samba-util tdb-wrap talloc_report
|
|
ctdb-ipalloc ctdb-protocol ctdb-util''',
|
|
includes='include',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('fake_ctdbd',
|
|
source='''tests/src/fake_ctdbd.c
|
|
tests/src/ipalloc_read_known_ips.c''',
|
|
deps='''ctdb-util ctdb-protocol ctdb-protocol-util
|
|
ctdb-system samba-util tevent-util
|
|
LIBASYNC_REQ popt''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
if bld.env.HAVE_INFINIBAND:
|
|
bld.SAMBA_BINARY('ibwrapper_test',
|
|
source='ib/ibwrapper_test.c',
|
|
includes='include',
|
|
deps='replace talloc ctdb-common sys_rw' +
|
|
ib_deps,
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
if bld.env.HAVE_ROBUST_MUTEXES and sys.platform.startswith('linux'):
|
|
bld.SAMBA_BINARY('test_mutex_raw',
|
|
source='tests/src/test_mutex_raw.c',
|
|
deps='pthread',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
test_subdirs = [
|
|
'complex',
|
|
'ctdb_eventd',
|
|
'cunit',
|
|
'eventd',
|
|
'eventscripts',
|
|
'onnode',
|
|
'shellcheck',
|
|
'simple',
|
|
'takeover',
|
|
'takeover_helper',
|
|
'tool'
|
|
]
|
|
|
|
if bld.env.standalone_ctdb:
|
|
testdir = 'tests'
|
|
else:
|
|
testdir = 'ctdb/tests'
|
|
|
|
for t in test_subdirs:
|
|
files = SUBDIR_MODE('%s/%s' % (testdir, t), trim_path=testdir)
|
|
for fmode in files:
|
|
bld.INSTALL_FILES(bld.env.CTDB_TEST_DATADIR, 'tests/%s' % fmode[0],
|
|
destname=fmode[0], chmod=fmode[1])
|
|
|
|
# Install tests/scripts directory without test_wrap
|
|
test_scripts = [
|
|
'common.sh',
|
|
'integration.bash',
|
|
'unit.sh'
|
|
]
|
|
|
|
for t in test_scripts:
|
|
bld.INSTALL_FILES(bld.env.CTDB_TEST_DATADIR,
|
|
os.path.join('tests/scripts', t),
|
|
destname=os.path.join('scripts', t))
|
|
|
|
sed_expr = 's@^TEST_SCRIPTS_DIR=.*@&\\nexport TEST_BIN_DIR=\"%s\"@' % (
|
|
bld.env.CTDB_TEST_LIBEXECDIR)
|
|
bld.SAMBA_GENERATOR('ctdb-test-wrap',
|
|
source='tests/scripts/test_wrap',
|
|
target='test_wrap',
|
|
rule='sed -e "%s" ${SRC} > ${TGT}' % sed_expr)
|
|
bld.INSTALL_FILES(bld.env.CTDB_TEST_DATADIR+"/scripts", 'test_wrap',
|
|
destname='test_wrap', chmod=0755)
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-test-script-install-paths',
|
|
source='tests/scripts/script_install_paths.sh',
|
|
target='script_install_paths.sh',
|
|
rule='sed %s ${SRC} > ${TGT}' % (sed_cmdline))
|
|
bld.INSTALL_FILES(bld.env.CTDB_TEST_DATADIR+"/scripts",
|
|
'script_install_paths.sh',
|
|
destname='script_install_paths.sh', chmod=0644)
|
|
|
|
sed_expr1 = 's@^\(export %s\)=.*@\\1=%s\\nexport %s=\"%s\"@''' % (
|
|
'CTDB_TEST_DIR', bld.env.CTDB_TEST_DATADIR,
|
|
'TEST_BIN_DIR', bld.env.CTDB_TEST_LIBEXECDIR)
|
|
sed_expr2 = 's@^\(export CTDB_TESTS_ARE_INSTALLED\)=false@\\1=true@'
|
|
bld.SAMBA_GENERATOR('ctdb-test-runner',
|
|
source='tests/run_tests.sh',
|
|
target='ctdb_run_tests.sh',
|
|
rule='sed -e "%s" -e "%s" ${SRC} > ${TGT}' % (
|
|
sed_expr1, sed_expr2))
|
|
bld.INSTALL_FILES('${BINDIR}', 'ctdb_run_tests.sh',
|
|
destname='ctdb_run_tests', chmod=0755)
|
|
bld.symlink_as(os.path.join(bld.env.BINDIR, 'ctdb_run_cluster_tests'),
|
|
'ctdb_run_tests')
|
|
|
|
|
|
def testonly(ctx):
|
|
cmd = 'tests/run_tests.sh -V tests/var'
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('tests exited with exit status %d' % ret)
|
|
sys.exit(ret)
|
|
|
|
|
|
def test(ctx):
|
|
import Scripting
|
|
Scripting.commands.append('build')
|
|
Scripting.commands.append('testonly')
|
|
|
|
|
|
def autotest(ctx):
|
|
env = samba_utils.LOAD_ENVIRONMENT()
|
|
cmd = 'tests/run_tests.sh -e -S %s' % env.SOCKET_WRAPPER_SO_PATH
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('autotest exited with exit status %d' % ret)
|
|
sys.exit(ret)
|
|
|
|
|
|
def show_version(ctx):
|
|
print VERSION
|
|
|
|
|
|
def manpages(ctx):
|
|
BASE_URL = 'http://docbook.sourceforge.net/release/xsl/current'
|
|
MAN_XSL = '%s/manpages/docbook.xsl' % BASE_URL
|
|
HTML_XSL = '%s/html/docbook.xsl' % BASE_URL
|
|
CMD_TEMPLATE = 'xsltproc --xinclude -o %s --nonet %s %s'
|
|
manpages = manpages_binary + manpages_misc + manpages_etcd + manpages_ceph
|
|
for t in manpages:
|
|
cmd = CMD_TEMPLATE % ('doc/%s' % t, MAN_XSL, 'doc/%s.xml' % t)
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('Command %s failed with exit status %d' % (cmd, ret))
|
|
sys.exit(ret)
|
|
|
|
cmd = CMD_TEMPLATE % ('doc/%s.html' % t, HTML_XSL, 'doc/%s.xml' % t)
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('Command %s failed with exit status %d' % (cmd, ret))
|
|
sys.exit(ret)
|
|
|
|
|
|
def distonly(ctx):
|
|
samba_dist.DIST_FILES('VERSION:VERSION', extend=True)
|
|
|
|
distfile = file('.distversion', 'w')
|
|
for field in version.vcs_fields:
|
|
distfile.write('%s=%s\n' % (field, str(version.vcs_fields[field])))
|
|
distfile.close()
|
|
samba_dist.DIST_FILES('ctdb/.distversion:.distversion', extend=True)
|
|
|
|
t = 'ctdb.spec'
|
|
sed_expr1 = 's/@VERSION@/%s/g' % VERSION
|
|
sed_expr2 = 's/@RELEASE@/%s/g' % '1'
|
|
cmd = 'sed -e "%s" -e "%s" packaging/RPM/ctdb.spec.in > %s' % (
|
|
sed_expr1, sed_expr2, t)
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('Command "%s" failed with exit status %d' % (cmd, ret))
|
|
sys.exit(ret)
|
|
samba_dist.DIST_FILES('ctdb/%s:%s' % (t, t), extend=True)
|
|
|
|
manpages = manpages_binary + manpages_misc + manpages_etcd + manpages_ceph
|
|
for t in manpages:
|
|
samba_dist.DIST_FILES('ctdb/doc/%s:doc/%s' % (t, t), extend=True)
|
|
samba_dist.DIST_FILES('ctdb/doc/%s.html:doc/%s.html' % (t, t),
|
|
extend=True)
|
|
|
|
samba_dist.dist()
|
|
|
|
|
|
def dist():
|
|
import Scripting
|
|
Scripting.commands.append('manpages')
|
|
Scripting.commands.append('distonly')
|
|
|
|
|
|
def rpmonly(ctx):
|
|
opts = os.getenv('RPM_OPTIONS') or ''
|
|
cmd = 'rpmbuild -ta --clean --rmsource %s ctdb-%s.tar.gz' % (opts, VERSION)
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('rpmbuild exited with exit status %d' % ret)
|
|
sys.exit(ret)
|
|
|
|
|
|
def rpm(ctx):
|
|
import Scripting
|
|
Scripting.commands.append('manpages')
|
|
Scripting.commands.append('distonly')
|
|
Scripting.commands.append('rpmonly')
|
|
|
|
|
|
def ctags(ctx):
|
|
"build 'tags' file using ctags"
|
|
import Utils
|
|
source_root = os.path.dirname(Utils.g_module.root_path)
|
|
cmd = 'ctags $(find %s -name "*.[ch]")' % source_root
|
|
print("Running: %s" % cmd)
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('ctags failed with exit status %d' % ret)
|
|
sys.exit(ret)
|