mirror of
https://github.com/samba-team/samba.git
synced 2024-12-24 21:34:56 +03:00
d1543d5c78
This forces the use pcap for packet capture on Linux. It appears that using a raw socket for capture does not work with infiniband - pcap support for that to come. Don't (yet?) change the default capture method to pcap. On some platforms (e.g. my personal Intel NUC, running Debian testing), pcap is much less reliable than the raw socket. However, pcap seems fine on most other platforms. Signed-off-by: Martin Schwenke <martin@meltin.net> Reviewed-by: Amitay Isaacs <amitay@gmail.com>
1329 lines
53 KiB
Python
1329 lines
53 KiB
Python
#!/usr/bin/env python
|
|
|
|
APPNAME = 'ctdb'
|
|
|
|
import sys, os
|
|
|
|
# find the buildtools directory
|
|
top = '.'
|
|
while not os.path.exists(top+'/buildtools') and len(top.split('/')) < 5:
|
|
top = top + '/..'
|
|
sys.path.insert(0, top + '/buildtools/wafsamba')
|
|
|
|
out = 'bin'
|
|
|
|
from waflib import Options, Logs, Errors, Context
|
|
import wafsamba
|
|
from wafsamba import samba_dist, samba_utils
|
|
from samba_utils import MODE_644, MODE_744, MODE_755, MODE_777
|
|
|
|
if os.path.isfile('./VERSION'):
|
|
vdir = '.'
|
|
elif os.path.isfile('../VERSION'):
|
|
vdir = '..'
|
|
else:
|
|
Logs.error("VERSION file not found")
|
|
|
|
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
|
|
lib/pthreadpool:lib/pthreadpool
|
|
lib/messaging:lib/messaging
|
|
buildtools:buildtools third_party/waf:third_party/waf''')
|
|
|
|
manpages_binary = [
|
|
'ctdb.1',
|
|
'ctdbd.1',
|
|
'ltdbtool.1',
|
|
'ping_pong.1'
|
|
]
|
|
|
|
manpages_misc = [
|
|
'ctdb_diagnostics.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',
|
|
]
|
|
|
|
VERSION = ''
|
|
|
|
def get_version():
|
|
import samba_version
|
|
env = samba_utils.LOAD_ENVIRONMENT()
|
|
|
|
return samba_version.samba_version_file('%s/VERSION' % vdir, vdir, env)
|
|
|
|
def get_version_string():
|
|
if Context.g_module.VERSION:
|
|
return Context.g_module.VERSION
|
|
version = get_version()
|
|
Context.g_module.VERSION = version.STRING.replace('-', '.')
|
|
return Context.g_module.VERSION
|
|
|
|
def 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('--enable-pcap',
|
|
help=("Use pcap for packet capture (default=no)"),
|
|
action="store_true", dest='ctdb_pcap', 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')
|
|
|
|
conf.CHECK_CODE('''pthread_mutex_t m;
|
|
int pid = 0;
|
|
m.__data.__owner = pid;
|
|
''',
|
|
'HAVE_PTHREAD_INTERNAL_MUTEX_OWNER',
|
|
headers='pthread.h',
|
|
msg='Checking for internal POSIX mutex owner field')
|
|
if not conf.env.HAVE_PTHREAD_INTERNAL_MUTEX_OWNER:
|
|
# This is unsupported - please see note in debug_locks.sh
|
|
Logs.info('Building without unsupported mutex debugging hack')
|
|
|
|
if conf.env.standalone_ctdb:
|
|
conf.SAMBA_CHECK_PERL(mandatory=True)
|
|
|
|
# This is just for consistency and to check the version for the
|
|
# build system, see Options.options.disable_python = True above
|
|
conf.SAMBA_CHECK_PYTHON()
|
|
conf.SAMBA_CHECK_PYTHON_HEADERS()
|
|
|
|
# We just want gnutls_rnd for rand subsystem
|
|
conf.CHECK_FUNCS_IN('gnutls_rnd', 'gnutls')
|
|
|
|
|
|
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 Errors.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 Errors.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')
|
|
conf.CHECK_FUNCS('getrusage', headers="sys/time.h sys/resource.h")
|
|
|
|
if not conf.CHECK_VARIABLE('ETIME', headers='errno.h'):
|
|
conf.DEFINE('ETIME', 'ETIMEDOUT')
|
|
|
|
if Options.options.ctdb_pcap or not sys.platform.startswith('linux'):
|
|
conf.DEFINE('ENABLE_PCAP', 1)
|
|
if not conf.env.ENABLE_PCAP:
|
|
conf.SET_TARGET_TYPE('pcap', 'EMPTY')
|
|
else:
|
|
conf.find_program('pcap-config', var='PCAP_CONFIG')
|
|
if conf.env.PCAP_CONFIG:
|
|
conf.CHECK_CFG(path=conf.env.PCAP_CONFIG,
|
|
args="--cflags --libs",
|
|
package="",
|
|
uselib_store="PCAP")
|
|
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.libcephfs_dir:
|
|
Logs.error('''--with-libcephfs no longer supported, please use compiler
|
|
flags instead, e.g. GCC LIBRARY_PATH and C_INCLUDE_PATH''')
|
|
sys.exit(1)
|
|
|
|
if Options.options.ctdb_ceph_reclock:
|
|
if (conf.CHECK_HEADERS('rados/librados.h', False, False, 'rados') and
|
|
conf.CHECK_LIB('rados', 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 Context.g_module.top == '.':
|
|
# 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 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)
|
|
|
|
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/pthreadpool')
|
|
bld.RECURSE('lib/messaging')
|
|
|
|
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'),
|
|
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',
|
|
'''cmdline.c
|
|
comm.c
|
|
conf.c
|
|
db_hash.c
|
|
event_script.c
|
|
hash_count.c
|
|
line.c
|
|
logging.c
|
|
path.c
|
|
pidfile.c
|
|
pkt_read.c
|
|
pkt_write.c
|
|
rb_tree.c
|
|
reqid.c
|
|
run_event.c
|
|
run_proc.c
|
|
sock_client.c
|
|
srvid.c
|
|
tmon.c
|
|
tunable.c
|
|
'''),
|
|
deps='''samba-util
|
|
LIBASYNC_REQ
|
|
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'''),
|
|
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
|
|
'''),
|
|
deps='''ctdb-protocol
|
|
ctdb-util
|
|
samba-util
|
|
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 tevent-util ctdb-util
|
|
talloc tevent
|
|
''',
|
|
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 = 'grep -Fv "register int32_t *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_PTHREAD_INTERNAL_MUTEX_OWNER:
|
|
bld.SAMBA_BINARY('tdb_mutex_check',
|
|
source='utils/tdb/tdb_mutex_check.c',
|
|
deps='tdb pthread',
|
|
install_path='${CTDB_HELPER_BINDIR}')
|
|
|
|
if bld.env.HAVE_PMDA:
|
|
bld.SAMBA_BINARY('pmdactdb',
|
|
source='utils/pmda/pmda_ctdb.c',
|
|
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',
|
|
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 = list(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=MODE_755)
|
|
|
|
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=MODE_755)
|
|
|
|
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=MODE_744)
|
|
|
|
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=MODE_755)
|
|
|
|
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=MODE_755)
|
|
|
|
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 & MODE_777
|
|
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': []}
|
|
for dirname, _subdirs, fnames in os.walk(path):
|
|
SUBDIR_MODE_callback(pd, dirname, fnames)
|
|
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=MODE_755)
|
|
|
|
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))
|
|
|
|
#
|
|
# Test-only below this point
|
|
#
|
|
|
|
if not bld.env.standalone_ctdb and not bld.CONFIG_GET('ENABLE_SELFTEST'):
|
|
return
|
|
|
|
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_util_tests = [
|
|
'cmdline_test',
|
|
'comm_client_test',
|
|
'comm_server_test',
|
|
'comm_test',
|
|
'conf_test',
|
|
'db_hash_test',
|
|
'event_script_test',
|
|
'hash_count_test',
|
|
'line_test',
|
|
'pidfile_test',
|
|
'pkt_read_test',
|
|
'pkt_write_test',
|
|
'run_event_test',
|
|
'run_proc_test',
|
|
'sock_io_test',
|
|
'srvid_test',
|
|
'tunable_test',
|
|
]
|
|
|
|
for target in ctdb_util_tests:
|
|
src = 'tests/src/' + target + '.c'
|
|
|
|
bld.SAMBA_BINARY(target,
|
|
source=src,
|
|
deps='''ctdb-tests-backtrace
|
|
LIBASYNC_REQ
|
|
samba-util
|
|
sys_rw
|
|
tevent-util
|
|
talloc
|
|
tevent
|
|
tdb
|
|
popt
|
|
''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('reqid_test',
|
|
source='tests/src/reqid_test.c',
|
|
deps='samba-util talloc',
|
|
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('system_socket_test',
|
|
source='tests/src/system_socket_test.c',
|
|
deps='''ctdb-tests-backtrace
|
|
talloc
|
|
ctdb-protocol-util
|
|
pcap
|
|
''',
|
|
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_BINARY('ctdb_io_test',
|
|
source='tests/src/ctdb_io_test.c',
|
|
deps='''talloc tevent tdb samba-util sys_rw''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_BINARY('ctdb-db-test',
|
|
source='tests/src/db_test_tool.c',
|
|
cflags='-DCTDB_DB_TEST_TOOL',
|
|
deps='''ctdb-client ctdb-protocol
|
|
ctdb-util samba-util talloc tevent replace''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
for target in ['tmon_ping_test', 'tmon_test']:
|
|
src = 'tests/src/' + target + '.c'
|
|
|
|
bld.SAMBA_BINARY(target,
|
|
source=src,
|
|
deps='''ctdb-util
|
|
ctdb-tests-backtrace
|
|
LIBASYNC_REQ
|
|
samba-util
|
|
sys_rw
|
|
tevent-util
|
|
talloc
|
|
tevent
|
|
tdb
|
|
popt
|
|
''',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol-tests-basic',
|
|
source=bld.SUBDIR('tests/src',
|
|
'protocol_common_basic.c'),
|
|
deps='samba-util replace talloc')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-protocol-tests-common',
|
|
source=bld.SUBDIR('tests/src',
|
|
'''protocol_common.c
|
|
protocol_common_ctdb.c
|
|
'''),
|
|
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
|
|
'''),
|
|
deps='''ctdb-client
|
|
samba-util
|
|
replace
|
|
popt
|
|
talloc
|
|
tevent
|
|
tdb''')
|
|
|
|
bld.SAMBA_SUBSYSTEM('ctdb-tests-backtrace',
|
|
source=bld.SUBDIR('tests/src',
|
|
'test_backtrace.c'),
|
|
deps='''samba-util
|
|
replace''')
|
|
|
|
# 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}')
|
|
|
|
bld.SAMBA_BINARY('cluster_mutex_test',
|
|
source='tests/src/cluster_mutex_test.c',
|
|
deps='''ctdb-tests-backtrace
|
|
samba-util
|
|
talloc
|
|
tevent
|
|
''',
|
|
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') and bld.env.DEVELOPER:
|
|
bld.SAMBA_BINARY('test_mutex_raw',
|
|
source='tests/src/test_mutex_raw.c',
|
|
deps='pthread',
|
|
install_path='${CTDB_TEST_LIBEXECDIR}')
|
|
|
|
test_subdirs = [
|
|
'CLUSTER',
|
|
'INTEGRATION',
|
|
'UNIT',
|
|
'etc-ctdb'
|
|
]
|
|
|
|
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, excluding files that need munging
|
|
test_scripts = [
|
|
'cluster.bash',
|
|
'common.sh',
|
|
'integration.bash',
|
|
'integration_local_daemons.bash',
|
|
'integration_real_cluster.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))
|
|
|
|
bld.INSTALL_FILES(bld.env.CTDB_TEST_DATADIR,
|
|
'tests/scripts/test_wrap',
|
|
destname='scripts/test_wrap',
|
|
chmod=MODE_755)
|
|
|
|
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=MODE_644)
|
|
|
|
sed_expr1 = 's@^\\(%s\\)=.*@\\1=%s@' % (
|
|
'CTDB_TEST_DIR', bld.env.CTDB_TEST_DATADIR)
|
|
sed_expr2 = 's@^\\(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=MODE_755)
|
|
bld.symlink_as(os.path.join(bld.env.BINDIR, 'ctdb_run_cluster_tests'),
|
|
'ctdb_run_tests')
|
|
|
|
bld.SAMBA_GENERATOR('ctdb-local-daemons',
|
|
source='tests/local_daemons.sh',
|
|
target='ctdb_local_daemons.sh',
|
|
rule='sed -e "%s" -e "%s" ${SRC} > ${TGT}' % (
|
|
sed_expr1, sed_expr2))
|
|
bld.INSTALL_FILES('${BINDIR}', 'ctdb_local_daemons.sh',
|
|
destname='ctdb_local_daemons', chmod=MODE_755)
|
|
|
|
|
|
def testonly(ctx):
|
|
cmd = 'tests/run_tests.sh'
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('tests exited with exit status %d' % ret)
|
|
sys.exit(ret)
|
|
|
|
|
|
def test(ctx):
|
|
Options.commands.append('build')
|
|
Options.commands.append('testonly')
|
|
|
|
|
|
def autotest(ctx):
|
|
env = samba_utils.LOAD_ENVIRONMENT()
|
|
cmd = 'tests/run_tests.sh -eL -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(get_version_string())
|
|
|
|
|
|
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)
|
|
|
|
t = 'ctdb.spec'
|
|
sed_expr1 = 's/@VERSION@/%s/g' % get_version_string()
|
|
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():
|
|
Options.commands.append('manpages')
|
|
Options.commands.append('distonly')
|
|
|
|
|
|
def rpmonly(ctx):
|
|
opts = os.getenv('RPM_OPTIONS') or ''
|
|
cmd = 'rpmbuild -ta --clean --rmsource %s ctdb-%s.tar.gz' % \
|
|
(opts, get_version_string())
|
|
ret = samba_utils.RUN_COMMAND(cmd)
|
|
if ret != 0:
|
|
print('rpmbuild exited with exit status %d' % ret)
|
|
sys.exit(ret)
|
|
|
|
|
|
def rpm(ctx):
|
|
Options.commands.append('manpages')
|
|
Options.commands.append('distonly')
|
|
Options.commands.append('rpmonly')
|
|
|
|
|
|
def ctags(ctx):
|
|
"build 'tags' file using ctags"
|
|
source_root = os.path.dirname(Context.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)
|