+++ /dev/null
-project = libmemcached
-version = 0.4.2
-template = pandora-build
-project-type = library
-pandora-version = 0.175
1.0.18
+* MEMCACHED_BEHAVIOR_RETRY_TIMEOUT can now be set to zero.
1.0.17 Tue Apr 2 14:02:01 HST 2013
* Remove c++ namespace that was being exposed (the API should be plug compatible)..
--- /dev/null
+# -*-Makefile-*-
+#
+_bootstrap_Makefile := $(wildcard [M]akefile)
+_bootstrap_config-status := $(wildcard config.status)
+
+ALL_RECURSIVE_TARGETS=
+
+ifneq ($(_bootstrap_Makefile),)
+ include Makefile
+else
+ ifneq ($(_bt_config-status),)
+ $(srcdir)/config.status
+ $(MAKE) $(AM_MAKEFLAGS) configure
+ endif
+
+.DEFAULT_GOAL:= basic_build
+srcdir= .
+
+configure: bootstrap.sh
+ @$(srcdir)/bootstrap.sh -a
+
+Makefile: configure
+ @$(srcdir)/bootstrap.sh -c
+
+.PHONY: basic_build
+basic_build: Makefile
+ @$(MAKE) $(AM_MAKEFLAGS)
+endif
+
+ALL_RECURSIVE_TARGETS+= $(AM_RECURSIVE_TARGETS)
+
+ifneq ($(word 2, $(MAKECMDGOALS)), )
+ifneq ($(filter $(ALL_RECURSIVE_TARGETS), $(MAKECMDGOALS)), )
+.NOTPARALLEL:
+endif
+endif
DISTCLEANFILES+= aminclude.am
-EXTRA_DIST+= .quickly
EXTRA_DIST+= README.FIRST
EXTRA_DIST+= README.win32
-rm -f m4/ltsugar.m4
-rm -f m4/ltversion.m4
-rm -f m4/lt~obsolete.m4
+ -rm -f m4/test-driver
-rmdir build-aux
-rm -rf ${top_builddir}/html
+ -rm -f bootstrap
# LIBTOOLIZE
# MAKE
# PREFIX
-# TESTS_ENVIRONMENT
+# LOG_COMPILER
# VERBOSE
# WARNINGS
#
die "OLD_MAKE($OLD_MAKE) was set on push, programmer error!"
fi
- if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
- die "OLD_TESTS_ENVIRONMENT($OLD_TESTS_ENVIRONMENT) was set on push, programmer error!"
+ if [[ -n "$OLD_LOG_COMPILER" ]]; then
+ die "OLD_LOG_COMPILER($OLD_LOG_COMPILER) was set on push, programmer error!"
fi
if [[ -n "$CONFIGURE" ]]; then
OLD_MAKE=$MAKE
fi
- if [[ -n "$TESTS_ENVIRONMENT" ]]; then
- OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT
+ if [[ -n "$LOG_COMPILER" ]]; then
+ OLD_LOG_COMPILER=$LOG_COMPILER
fi
}
MAKE=$OLD_MAKE
fi
- if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
- TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT
+ if [[ -n "$OLD_LOG_COMPILER" ]]; then
+ LOG_COMPILER=$OLD_LOG_COMPILER
fi
OLD_CONFIGURE=
OLD_CONFIGURE_ARG=
OLD_PREFIX=
OLD_MAKE=
- OLD_TESTS_ENVIRONMENT=
+ OLD_LOG_COMPILER=
export -n CC CXX
}
# If we don't have a configure, then most likely we will be missing libtool
assert_file 'configure'
if [[ -x 'libtool' ]]; then
- TESTS_ENVIRONMENT="./libtool --mode=execute $VALGRIND_COMMAND"
+ LOG_COMPILER="./libtool --mode=execute $VALGRIND_COMMAND"
else
- TESTS_ENVIRONMENT="$VALGRIND_COMMAND"
+ LOG_COMPILER="$VALGRIND_COMMAND"
fi
make_target 'all'
else
if [[ -n "$DISPLAY" ]]; then
if command_exists 'wine'; then
- TESTS_ENVIRONMENT='wine'
+ LOG_COMPILER='wine'
fi
fi
- if [[ -n "$TESTS_ENVIRONMENT" ]]; then
+ if [[ -n "$LOG_COMPILER" ]]; then
make_target 'check' 'warn' || warn "$MAKE check failed"
ret=$?
fi
# If we don't have a configure, then most likely we will be missing libtool
assert_file 'configure'
if [[ -f 'libtool' ]]; then
- TESTS_ENVIRONMENT="./libtool --mode=execute $GDB_COMMAND"
+ LOG_COMPILER="./libtool --mode=execute $GDB_COMMAND"
else
- TESTS_ENVIRONMENT="$GDB_COMMAND"
+ LOG_COMPILER="$GDB_COMMAND"
fi
make_target 'check'
run_configure
fi
- if [ -n "$TESTS_ENVIRONMENT" ]; then
+ if [ -n "$LOG_COMPILER" ]; then
if $verbose; then
- echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
+ echo "LOG_COMPILER=$LOG_COMPILER"
fi
fi
echo "MAKE=$MAKE"
fi
- if [[ -n "$MAKE_TARGET" ]]; then
- echo "MAKE_TARGET=$MAKE_TARGET"
+ if [[ -n "$BOOTSTRAP_TARGET" ]]; then
+ echo "BOOTSTRAP_TARGET=$BOOTSTRAP_TARGET"
fi
if [[ -n "$PREFIX" ]]; then
echo "PREFIX=$PREFIX"
fi
- if [[ -n "$TESTS_ENVIRONMENT" ]]; then
- echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
+ if [[ -n "$LOG_COMPILER" ]]; then
+ echo "LOG_COMPILER=$LOG_COMPILER"
fi
if [[ -n "$VCS_CHECKOUT" ]]; then
execute_job ()
{
# We should always have a target by this point
- assert MAKE_TARGET
+ assert BOOTSTRAP_TARGET
determine_target_platform
fi
fi
- # Use OLD_TESTS_ENVIRONMENT for tracking the state of the variable
- local OLD_TESTS_ENVIRONMENT=
+ # Use OLD_LOG_COMPILER for tracking the state of the variable
+ local OLD_LOG_COMPILER=
# Set ENV PREFIX in order to set --prefix for ./configure
if [[ -n "$PREFIX" ]]; then
make_maintainer_clean
fi
- local MAKE_TARGET_ARRAY
- MAKE_TARGET_ARRAY=( $MAKE_TARGET )
+ local BOOTSTRAP_TARGET_ARRAY
+ BOOTSTRAP_TARGET_ARRAY=( $BOOTSTRAP_TARGET )
- for target in "${MAKE_TARGET_ARRAY[@]}"
+ for target in "${BOOTSTRAP_TARGET_ARRAY[@]}"
do
# If we are running inside of Jenkins, we want to only run some of the possible tests
if $jenkins_build_environment; then
check_make_target $target
ret=$?
if [ $ret -ne 0 ]; then
- die "Unknown MAKE_TARGET option: $target"
+ die "Unknown BOOTSTRAP_TARGET option: $target"
fi
fi
declare -x VCS_CHECKOUT=
# Variables we control globally
- local -a MAKE_TARGET=
+ local -a BOOTSTRAP_TARGET=
local CONFIGURE=
local use_libtool=false
local verbose=false
local OLD_CONFIGURE_ARG=
local OLD_PREFIX=
local OLD_MAKE=
- local OLD_TESTS_ENVIRONMENT=
+ local OLD_LOG_COMPILER=
# If we call autoreconf on the platform or not
local AUTORECONF_REBUILD_HOST=false
local OPT_TARGET=
parse_command_line_options "$@"
- nassert MAKE_TARGET
+ nassert BOOTSTRAP_TARGET
if [ -n "$OPT_TARGET" ]; then
- MAKE_TARGET="$OPT_TARGET"
+ BOOTSTRAP_TARGET="$OPT_TARGET"
fi
# If we are running under Jenkins we predetermine what tests we will run against
- # This MAKE_TARGET can be overridden by parse_command_line_options based MAKE_TARGET changes.
+ # This BOOTSTRAP_TARGET can be overridden by parse_command_line_options based BOOTSTRAP_TARGET changes.
# We don't want Jenkins overriding other variables, so we NULL them.
- if [ -z "$MAKE_TARGET" ]; then
+ if [ -z "$BOOTSTRAP_TARGET" ]; then
if $jenkins_build_environment; then
if [[ -n "$JENKINS_TARGET" ]]; then
- MAKE_TARGET="$JENKINS_TARGET"
- else
- if [[ -n "$label" ]]; then
- check_make_target $label
- if [ $? -eq 0 ]; then
- MAKE_TARGET="$label"
- fi
- fi
-
- if [[ -n "$LABEL" ]]; then
- check_make_target $LABEL
- if [ $? -eq 0 ]; then
- MAKE_TARGET="$LABEL"
- fi
- fi
-
- if [ -z "$MAKE_TARGET" ]; then
- MAKE_TARGET='jenkins'
+ check_make_target $JENKINS_TARGET
+ if [ $? -eq 0 ]; then
+ BOOTSTRAP_TARGET="$JENKINS_TARGET"
+ else
+ die "label not found: $label"
fi
+ else
+ BOOTSTRAP_TARGET='jenkins'
fi
fi
fi
- if [ -z "$MAKE_TARGET" ]; then
- MAKE_TARGET="make_default"
+ if [ -z "$BOOTSTRAP_TARGET" ]; then
+ BOOTSTRAP_TARGET="make_default"
fi
# We should always have a target by this point
- assert MAKE_TARGET
+ assert BOOTSTRAP_TARGET
execute_job
local ret=$?
export LIBTOOLIZE_OPTIONS
export MAKE
export PREFIX_ARG
- export TESTS_ENVIRONMENT
+ export LOG_COMPILER
export VERBOSE
export WARNINGS
clients_memaslap_LDADD+= @LIBEVENT_LIB@
clients_memaslap_LDADD+= $(CLIENTS_LDADDS)
+clients_memcapable_CXXFLAGS= @PTHREAD_CFLAGS@
clients_memcapable_SOURCES=
clients_memcapable_SOURCES+= clients/memcapable.cc
clients_memcapable_SOURCES+= libmemcached/byteorder.cc
clients_memcapable_LDADD= $(CLIENTS_LDADDS)
+clients_memcapable_LDADD+= @PTHREAD_LIBS@
test-start-server:
clients/memflush --servers=localhost
or (errno != 0 && val == 0))
{
*error= true;
- return EXIT_SUCCESS;
+ return 0;
}
if (endptr == nptr)
{
*error= true;
- return EXIT_SUCCESS;
+ return 0;
}
*error= false;
case OPT_EXPIRE: /* --expire */
{
bool strtol_error;
- opt_expires= (time_t)strtol_wrapper(optarg, 16, &strtol_error);
+ opt_expires= (time_t)strtol_wrapper(optarg, 10, &strtol_error);
if (strtol_error == true)
{
- fprintf(stderr, "Bad value passed via --flag\n");
+ fprintf(stderr, "Bad value passed via --expire\n");
exit(1);
}
}
# the COPYING file in this directory for full text.
m4_include([version.m4])
+AC_PREREQ([2.61])
AC_INIT([libmemcached],VERSION_NUMBER,[http://libmemcached.org/])
+
+# Setup the compilers early on
+AC_PROG_CC([cc gcc clang])
+AC_PROG_CXX([c++ g++ clang++])
+
AC_CONFIG_AUX_DIR([build-aux])
AC_CONFIG_MACRO_DIR([m4])
-AC_CANONICAL_TARGET
+AC_CANONICAL_HOST
AC_ARG_PROGRAM
AC_USE_SYSTEM_EXTENSIONS
AM_INIT_AUTOMAKE([1.11 color-tests -Wno-portability subdir-objects foreign tar-ustar])
-AC_PREREQ([2.61])
-
AC_CONFIG_HEADERS([mem_config.h:mem_config.in])dnl Keep filename to 8.3 for MS-DOS.
AC_SUBST([AUTOHEADER_FILE],[mem_config.h])
AC_CONFIG_SRCDIR([libmemcached/memcached.cc])
m4_include([libhashkit/include.m4])
LT_PREREQ([2.2])
-LT_INIT
+LT_INIT([dlopen])
LT_LANG([C++])
LT_LIB_M
+AC_SUBST([lt_cv_dlopen_libs])
+
+
AC_PROG_CC_C99
AS_IF([test "x${ac_cv_prog_cc_c99}" == "xno"],[AC_MSG_ERROR([No c99 compatible compiler found])])
AC_DEFUN([CHECK_CXX0X],[
AC_LANG_PUSH([C++])
AX_CHECK_COMPILE_FLAG([-std=c++0x],[
- CXXFLAGS="$CXXFLAGS -std=c++0x"])
+ CXX="$CXX -std=c++0x"])
AC_LANG_POP([C++])
])
CHECK_CXX0X
AX_ASSERT
AX_PLATFORM
-
m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
-AX_CXX_HEADER_STDCXX_98
-AS_IF([test "x$ax_cv_cxx_stdcxx_98" = "xno"],
- [AC_MSG_ERROR([Your system lacks a new enough C++ compiler])])
-
AC_DEFUN([LIBMEMCACHED_PROTOCOL],
[AC_ARG_ENABLE([libmemcachedprotocol],
[AS_HELP_STRING([--enable-libmemcachedprotocol],
[AC_DEFINE([HAVE_CLOCK_GETTIME],[0],[Have clock_gettime])])
-# Check for the ability to call dlopen (used in libhostile)
-AX_DLOPEN
-
AC_CHECK_HEADERS([atomic.h])
AS_IF([test "x$ac_cv_header_atomic_h" = "xyes"],
[AC_CHECK_FUNCS([atomic_add_64])
AX_UUID_GENERATE_TIME_SAFE
AC_DEFUN([CHECK_FOR_PTHREAD_AND_SASL],
- [AX_PTHREAD(, [AC_MSG_ERROR([could not find libpthread])])
+ [AC_LANG_PUSH([C++])
+ AX_PTHREAD(, [AC_MSG_ERROR([could not find libpthread])])
AX_PTHREAD_TIMEDJOIN_NP
+ AC_LANG_POP([C++])
# The sasl functions should only be visible if we build with sasl support
#
break;
case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
- if (data == 0)
- {
- return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
- memcached_literal_param("MEMCACHED_BEHAVIOR_RETRY_TIMEOUT requires a value greater then zero."));
- }
ptr->retry_timeout= int32_t(data);
break;
struct addrinfo hints;
memset(&hints, 0, sizeof(struct addrinfo));
- hints.ai_family= AF_INET;
+ hints.ai_family= AF_UNSPEC;
if (memcached_is_udp(server->root))
{
hints.ai_protocol= IPPROTO_UDP;
*error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop
memcached_instance_st *server;
memcached_return_t read_ret= MEMCACHED_SUCCESS;
+ bool connection_failures= false;
while ((server= memcached_io_get_readable_server(ptr, read_ret)))
{
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
{
continue;
}
+ else if (*error == MEMCACHED_CONNECTION_FAILURE)
+ {
+ connection_failures= true;
+ continue;
+ }
else if (*error == MEMCACHED_SUCCESS)
{
result->count++;
{
*error= MEMCACHED_NOTFOUND;
}
+ else if (connection_failures)
+ {
+ /*
+ If we have a connection failure to some servers, the caller may
+ wish to treat that differently to getting a definitive NOT_FOUND
+ from all servers, so return MEMCACHED_CONNECTION_FAILURE to allow
+ that.
+ */
+ *error= MEMCACHED_CONNECTION_FAILURE;
+ }
else if (*error == MEMCACHED_SUCCESS)
{
*error= MEMCACHED_END;
# included from Top Level Makefile.am
# All paths should be given relative to the root
-libmemcached_libmemcached_la_SOURCES =
+libmemcached_libmemcached_la_SOURCES=
include libmemcached/csl/include.am
EXTRA_libmemcached_libmemcached_la_DEPENDENCIES=
libmemcached_libmemcached_la_LIBADD=
libmemcached_libmemcached_la_LDFLAGS=
-libmemcached_libmemcached_la_CFLAGS= -DBUILDING_LIBMEMCACHED
-libmemcached_libmemcached_la_CXXFLAGS= -DBUILDING_LIBMEMCACHED
+libmemcached_libmemcached_la_CFLAGS=
+libmemcached_libmemcached_la_CXXFLAGS=
+
+libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_LIBMEMCACHED
+libmemcached_libmemcached_la_CXXFLAGS+= -DBUILDING_LIBMEMCACHED
if BUILD_WIN32
libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_HASHKIT
libmemcached/options.cc: libmemcached/csl/parser.h
libmemcached_libmemcached_la_LDFLAGS+= -version-info ${MEMCACHED_LIBRARY_VERSION}
-libmemcached_libmemcached_la_LIBADD+= @DL_LIB@
+libmemcached_libmemcached_la_LIBADD+= @lt_cv_dlopen_libs@
if HAVE_SASL
+libmemcached_libmemcached_la_CFLAGS+= @PTHREAD_CFLAGS@
libmemcached_libmemcached_la_CXXFLAGS+= @PTHREAD_CFLAGS@
libmemcached_libmemcached_la_LIBADD+= @PTHREAD_LIBS@
-libmemcached_libmemcached_la_LIBADD+= @LIBSASL_LIB@
+libmemcached_libmemcached_la_LIBADD+= @SASL_LIB@
endif
if HAVE_DTRACE
instance->close_socket();
- if (io_death)
+ if (io_death and memcached_is_udp(instance->root))
{
+ /*
+ If using UDP, we should stop using the server briefly on every IO
+ failure. If using TCP, it may be that the connection went down a
+ short while ago (e.g. the server failed) and we've only just
+ noticed, so we should only set the retry timeout on a connect
+ failure (which doesn't call this method).
+ */
memcached_mark_server_for_timeout(instance);
}
}
{
if (server->state != MEMCACHED_SERVER_STATE_IN_TIMEOUT)
{
- struct timeval next_time;
- if (gettimeofday(&next_time, NULL) == 0)
+ if (server->root->retry_timeout != 0)
{
- server->next_retry= next_time.tv_sec +server->root->retry_timeout;
- }
- else
- {
- server->next_retry= 1; // Setting the value to 1 causes the timeout to occur immediatly
- }
+ struct timeval next_time;
+ if (gettimeofday(&next_time, NULL) == 0)
+ {
+ server->next_retry= next_time.tv_sec +server->root->retry_timeout;
+ }
+ else
+ {
+ server->next_retry= 1; // Setting the value to 1 causes the timeout to occur immediatly
+ }
- server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
+ server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
+ }
if (server->server_failure_counter_query_id != server->root->query_id)
{
server->server_failure_counter++;
{
if (self->virtual_bucket)
{
- if (self->virtual_bucket)
- {
- uint32_t result= (uint32_t) (digest & (self->virtual_bucket->size -1));
- return self->virtual_bucket->buckets[result].master;
- }
-
- return (uint32_t) (digest & (self->number_of_hosts -1));
+ uint32_t result= (uint32_t) (digest & (self->virtual_bucket->size -1));
+ return self->virtual_bucket->buckets[result].master;
}
+
+ return (uint32_t) (digest & (self->number_of_hosts -1));
}
return 0;
bool gdb_is_caller(void)
{
- if (bool(getenv("TESTS_ENVIRONMENT")) and strstr(getenv("TESTS_ENVIRONMENT"), "gdb"))
+ if (bool(getenv("LOG_COMPILER")) and strstr(getenv("LOG_COMPILER"), "gdb"))
{
return true;
}
bool helgrind_is_caller(void)
{
- if (bool(getenv("TESTS_ENVIRONMENT")) and strstr(getenv("TESTS_ENVIRONMENT"), "helgrind"))
+ if (bool(getenv("LOG_COMPILER")) and strstr(getenv("LOG_COMPILER"), "helgrind"))
{
return true;
}
namespace libtest {
+std::string& escape4XML(std::string const& arg, std::string& escaped_string)
+{
+ escaped_string.clear();
+
+ escaped_string+= '"';
+ for (std::string::const_iterator x= arg.begin(), end= arg.end(); x != end; ++x)
+ {
+ unsigned char c= *x;
+ if (c == '&')
+ {
+ escaped_string+= "&";
+ }
+ else if (c == '>')
+ {
+ escaped_string+= ">";
+ }
+ else if (c == '<')
+ {
+ escaped_string+= "<";
+ }
+ else if (c == '\'')
+ {
+ escaped_string+= "'"; break;
+ }
+ else if (c == '"')
+ {
+ escaped_string+= """;
+ }
+ else if (c == ' ')
+ {
+ escaped_string+= ' ';
+ }
+ else if (isalnum(c))
+ {
+ escaped_string+= c;
+ }
+ else
+ {
+ char const* const hexdig= "0123456789ABCDEF";
+ escaped_string+= "&#x";
+ escaped_string+= hexdig[c >> 4];
+ escaped_string+= hexdig[c & 0xF];
+ escaped_string+= ';';
+ }
+ }
+ escaped_string+= '"';
+
+ return escaped_string;
+}
+
class TestCase {
public:
TestCase(const std::string& arg):
void Formatter::skipped()
{
current()->result(TEST_SKIPPED);
- Out << name() << "." << current()->name() << "\t\t\t\t\t" << "[ " << test_strerror(current()->result()) << " ]";
+ Out << name() << "."
+ << current()->name()
+ << "\t\t\t\t\t"
+ << "[ " << test_strerror(current()->result()) << " ]";
reset();
}
assert(current());
current()->result(TEST_FAILURE);
- Out << name() << "." << current()->name() << "\t\t\t\t\t" << "[ " << test_strerror(current()->result()) << " ]";
+ Out << name()
+ << "." << current()->name() << "\t\t\t\t\t"
+ << "[ " << test_strerror(current()->result()) << " ]";
reset();
}
{
assert(current());
current()->result(TEST_SUCCESS, timer_);
+ std::string escaped_string;
Out << name() << "."
<< current()->name()
void Formatter::xml(libtest::Framework& framework_, std::ofstream& output)
{
- output << "<testsuites name=\"" << framework_.name() << "\">" << std::endl;
+ std::string escaped_string;
+
+ output << "<testsuites name="
+ << escape4XML(framework_.name(), escaped_string) << ">" << std::endl;
+
for (Suites::iterator framework_iter= framework_.suites().begin();
framework_iter != framework_.suites().end();
++framework_iter)
{
- output << "\t<testsuite name=\"" << (*framework_iter)->name() << "\" classname=\"\" package=\"\">" << std::endl;
+ output << "\t<testsuite name="
+ << escape4XML((*framework_iter)->name(), escaped_string)
+#if 0
+ << " classname=\"\" package=\"\""
+#endif
+ << ">" << std::endl;
for (TestCases::iterator case_iter= (*framework_iter)->formatter()->testcases().begin();
case_iter != (*framework_iter)->formatter()->testcases().end();
++case_iter)
{
- output << "\t\t<testcase name=\""
- << (*case_iter)->name()
- << "\" time=\""
+ output << "\t\t<testcase name="
+ << escape4XML((*case_iter)->name(), escaped_string)
+ << " time=\""
<< (*case_iter)->timer().elapsed_milliseconds()
- << "\">"
- << std::endl;
+ << "\"";
switch ((*case_iter)->result())
{
case TEST_SKIPPED:
+ output << ">" << std::endl;
output << "\t\t <skipped/>" << std::endl;
+ output << "\t\t</testcase>" << std::endl;
break;
case TEST_FAILURE:
+ output << ">" << std::endl;
output << "\t\t <failure message=\"\" type=\"\"/>"<< std::endl;
+ output << "\t\t</testcase>" << std::endl;
break;
case TEST_SUCCESS:
+ output << "/>" << std::endl;
break;
}
- output << "\t\t</testcase>" << std::endl;
}
output << "\t</testsuite>" << std::endl;
}
LIBTOOL_COMMAND= ${abs_top_builddir}/libtool --mode=execute
VALGRIND_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=memcheck --error-exitcode=1 --leak-check=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
SGCHECK_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=exp-sgcheck --error-exitcode=1
-VALGRIND_COMMAND= TESTS_ENVIRONMENT="valgrind" $(VALGRIND_EXEC_COMMAND)
+VALGRIND_COMMAND= LOG_COMPILER="valgrind" $(VALGRIND_EXEC_COMMAND)
HELGRIND_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=helgrind --read-var-info=yes --error-exitcode=1 --read-var-info=yes
DRD_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=drd --free-is-write=yes --error-exitcode=1
SGCHECK_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=exp-sgcheck --error-exitcode=1
export GDB_COMMAND
valgrind:
- @echo make check TESTS_ENVIRONMENT="\"$(VALGRIND_EXEC_COMMAND)\""
+ @echo make check LOG_COMPILER="\"$(VALGRIND_EXEC_COMMAND)\""
sgcheck:
- @echo make check TESTS_ENVIRONMENT="\"$(SGCHECK_EXEC_COMMAND)\""
+ @echo make check LOG_COMPILER="\"$(SGCHECK_EXEC_COMMAND)\""
valgrind-supressions:
- @echo make check TESTS_ENVIRONMENT="\"$(VALGRIND_SUPRESSION)\""
+ @echo make check LOG_COMPILER="\"$(VALGRIND_SUPRESSION)\""
gdb:
- @echo make check TESTS_ENVIRONMENT="\"$(GDB_COMMAND)\""
+ @echo make check LOG_COMPILER="\"$(GDB_COMMAND)\""
helgrind:
- @echo make check TESTS_ENVIRONMENT="\"$(HELGRIND_COMMAND)\""
+ @echo make check LOG_COMPILER="\"$(HELGRIND_COMMAND)\""
drd:
- @echo make check TESTS_ENVIRONMENT="\"$(DRD_COMMAND)\""
+ @echo make check LOG_COMPILER="\"$(DRD_COMMAND)\""
EXTRA_DIST+= libtest/run.gdb
EXTRA_DIST+= libtest/version.h
# We are either building in tree, or with
libtest_libtest_la_SOURCES+= libtest/memcached.cc
+if HAVE_LIBDRIZZLE
libtest_libtest_la_LDFLAGS+= @LIBDRIZZLE_LDFLAGS@
libtest_libtest_la_LIBADD+= @LIBDRIZZLE_LIB@
+endif
libtest_libtest_la_SOURCES+= libtest/gearmand.cc
libtest_backtrace_LDADD=
libtest_backtrace_SOURCES+= libtest/backtrace_test.cc
libtest_backtrace_SOURCES+= libmemcached/backtrace.cc
-libtest_backtrace_LDADD+= @DL_LIB@
+libtest_backtrace_LDADD+= @lt_cv_dlopen_libs@
noinst_PROGRAMS+= libtest/backtrace
test-backtrace: libtest/backtrace
@libtest/backtrace
server_startup_st *servers= (server_startup_st*)object;
test_true(servers);
- test_skip(false, bool(getenv("TESTS_ENVIRONMENT")));
+ test_skip(false, bool(getenv("LOG_COMPILER")));
if (MEMCACHED_SASL_BINARY)
{
static inline bool valgrind_is_caller(void)
{
- if (getenv("TESTS_ENVIRONMENT") && strstr(getenv("TESTS_ENVIRONMENT"), "valgrind"))
+ if (getenv("LOG_COMPILER") && strstr(getenv("LOG_COMPILER"), "valgrind"))
{
- if (strstr(getenv("TESTS_ENVIRONMENT"), "--tool") == NULL)
+ if (strstr(getenv("LOG_COMPILER"), "--tool") == NULL)
{
return true;
}
- if (strstr(getenv("TESTS_ENVIRONMENT"), "--tool=memcheck"))
+ if (strstr(getenv("LOG_COMPILER"), "--tool=memcheck"))
{
return true;
}
AS_IF([test "$]AS_TR_SH([ax_cv_have_]$1)[" = "yes"],
[AC_DEFINE([HAVE_]$1, [1], [Define to 1 if ]$1[ is found])
- AC_SUBST($1[_CPPFLAGS])
- AC_SUBST($1[_LDFLAGS])
- AC_SUBST($1[_LIB],[-l]$3)
ifelse([$4], , :, [$4])],
[ifelse([$5], , :, [$5])])
])
#
# SYNOPSIS
#
-# AX_COMPILER_VENDOR()
+# AX_COMPILER_VENDOR
#
# DESCRIPTION
#
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
-#serial 11
+#serial 12
AC_DEFUN([AX_COMPILER_VENDOR],
[AC_CACHE_CHECK([for _AC_LANG compiler vendor], ax_cv_[]_AC_LANG_ABBREV[]_compiler_vendor,
ibm: __xlc__,__xlC__,__IBMC__,__IBMCPP__
pathscale: __PATHCC__,__PATHSCALE__
clang: __clang__
+ fujitsu: __FUJITSU
gnu: __GNUC__
sun: __SUNPRO_C,__SUNPRO_CC
hp: __HP_cc,__HP_aCC
+++ /dev/null
-#serial 2
-
-AC_DEFUN([AX_DLOPEN],
- [AS_IF([test "x$enable_shared" = xyes],
- [AX_CHECK_LIBRARY([DL],[dlfcn.h],[dl],
- [AC_DEFINE([HAVE_LIBDL],[1],[Have dlopen])
- AC_CHECK_LIB([dl],[dlopen],[AC_DEFINE([HAVE_DLOPEN],[1],[Have dlopen])])
- AC_CHECK_LIB([dl],[dladdr],[AC_DEFINE([HAVE_DLADDR],[1],[Have dladdr])])])])
- ])
-
_APPEND_COMPILE_FLAGS_ERROR([-Wunused-parameter])
_APPEND_COMPILE_FLAGS_ERROR([-Wunused-local-typedefs])
_APPEND_COMPILE_FLAGS_ERROR([-Wwrite-strings])
- _APPEND_COMPILE_FLAGS_ERROR([-floop-parallelize-all])
_APPEND_COMPILE_FLAGS_ERROR([-fwrapv])
_APPEND_COMPILE_FLAGS_ERROR([-fmudflapt])
_APPEND_COMPILE_FLAGS_ERROR([-pipe])
_APPEND_COMPILE_FLAGS_ERROR([-Wunused-local-typedefs])
_APPEND_COMPILE_FLAGS_ERROR([-Wwrite-strings])
_APPEND_COMPILE_FLAGS_ERROR([-Wformat-security])
- _APPEND_COMPILE_FLAGS_ERROR([-floop-parallelize-all])
_APPEND_COMPILE_FLAGS_ERROR([-fwrapv])
_APPEND_COMPILE_FLAGS_ERROR([-fmudflapt])
_APPEND_COMPILE_FLAGS_ERROR([-pipe])
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
-#serial 22
+#serial 23
AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
AC_DEFUN([AX_PTHREAD], [
#
# SYNOPSIS
#
-# AX_RESTORE_FLAGS()
+# AX_RESTORE_FLAGS([namespace])
#
# DESCRIPTION
#
-# Restore common compilation flags from temporary variables
+# Restore common compilation flags from temporary variables.
+#
+# Compilation flags includes: CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS, LIBS,
+# OBJCFLAGS.
+#
+# By default these flags are restored to a global (empty) namespace, but
+# user could restore from specific NAMESPACE by using
+# AX_RESTORE_FLAGS(NAMESPACE) macro.
+#
+# Typical usage is like:
+#
+# AX_SAVE_FLAGS(mypackage)
+# CPPFLAGS="-Imypackagespath ${CPPFLAGS}"
+# dnl ... do some detection ...
+# AX_RESTORE_FLAGS(mypackage)
#
# LICENSE
#
# Copyright (c) 2009 Filippo Giunchedi <filippo@esaurito.net>
+# Copyright (c) 2011 The Board of Trustees of the Leland Stanford Junior University
+# Copyright (c) 2011 Russ Allbery <rra@stanford.edu>
+# Copyright (c) 2013 Bastien ROUCARIES <roucaries.bastien+autoconf@gmail.com>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 3
+#serial 6
+
+# save one flag in name space
+AC_DEFUN([_AX_RESTORE_ONE_FLAG],[dnl
+ AS_VAR_PUSHDEF([_ax_restore_flag_var], [$2[]_$1[]_ax_save_flags])
+ AS_VAR_COPY($2[],_ax_restore_flag_var)
+ AS_VAR_POPDEF([_ax_restore_flag_var])
+])
-AC_DEFUN([AX_RESTORE_FLAGS], [
- CPPFLAGS="${CPPFLAGS_save}"
- CFLAGS="${CFLAGS_save}"
- CXXFLAGS="${CXXFLAGS_save}"
- OBJCFLAGS="${OBJCFLAGS_save}"
- LDFLAGS="${LDFLAGS_save}"
- LIBS="${LIBS_save}"
+AC_DEFUN([AX_RESTORE_FLAGS], [dnl
+ m4_foreach([FLAG], dnl
+ [_AX_SAVE_FLAGS_LIST()], dnl
+ [_AX_RESTORE_ONE_FLAG([$1],FLAG)])
])
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 2
+#serial 3
AC_DEFUN([AX_SASL_OPTION],
- [AC_REQUIRE([AX_SASL_CHECK])
- AC_ARG_ENABLE([sasl],
- [AS_HELP_STRING([--disable-sasl], [Build with sasl support @<:@default=on@:>@])],
- [ac_enable_sasl="$enableval"],
- [ac_enable_sasl=yes])
+ [AC_REQUIRE([AX_SASL_CHECK])
+ AC_ARG_ENABLE([sasl],
+ [AS_HELP_STRING([--disable-sasl], [Build with sasl support @<:@default=on@:>@])],
+ [ac_enable_sasl="$enableval"],
+ [ac_enable_sasl=yes])
- AS_IF([test "x${ac_enable_sasl}" = xyes],
- [AC_MSG_CHECKING([checking to see if enabling sasl])
- AS_IF([test "x${ax_sasl_check}" = xyes],
- [ax_sasl_option=yes],
- [AC_MSG_WARN([request to add sasl support failed, please see config.log])
- ac_enable_sasl=no
- ax_sasl_option=no])
- AC_MSG_RESULT(["$ax_sasl_option"])
- ])
- AM_CONDITIONAL([HAVE_SASL],[test "x${ax_sasl_option}" = xyes])
- ])
+ AS_IF([test "x${ac_enable_sasl}" = xyes],[
+ AC_MSG_CHECKING([checking to see if enabling sasl])
+ AS_IF([test "x${ax_sasl_check}" = xyes],[
+ ax_sasl_option=yes],[
+ AC_MSG_WARN([request to add sasl support failed, please see config.log])
+ ac_enable_sasl=no
+ ax_sasl_option=no])
+ AC_MSG_RESULT(["$ax_sasl_option"])],[
+ ax_sasl_option=no])
+ AM_CONDITIONAL([HAVE_SASL],[test "x${ax_sasl_option}" = xyes])
+ ])
-AC_DEFUN([AX_SASL_CHECK],
- [ax_sasl_check=no
- AX_CHECK_LIBRARY([LIBSASL],[sasl/sasl.h],[sasl2],
- [ax_sasl_check=yes
- AC_SUBST([SASL_LIB],[[-lsasl2]])
- ])
- AC_MSG_CHECKING([checking to see if sasl works])
- AC_MSG_RESULT(["$ax_sasl_check"])
- ])
+AC_DEFUN([AX_SASL_CHECK],[
+ AX_CHECK_LIBRARY([LIBSASL],[sasl/sasl.h],[sasl2],[
+ ax_sasl_check=yes
+ AC_SUBST([SASL_LIB],[[-lsasl2]])],[
+ ax_sasl_check=no])
+ AC_MSG_CHECKING([checking to see if sasl works])
+ AC_MSG_RESULT(["$ax_sasl_check"])
+ ])
#
# SYNOPSIS
#
-# AX_SAVE_FLAGS()
+# AX_SAVE_FLAGS([NAMESPACE])
#
# DESCRIPTION
#
-# Save common compilation flags into temporary variables
+# Save common compilation flags into temporary variables.
+#
+# Compilation flags includes: CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS, LIBS,
+# OBJCFLAGS.
+#
+# By default these flags are saved to a global (empty) namespace, but user
+# could specify a specific NAMESPACE to AX_SAVE_FLAGS macro and latter
+# restore it by using AX_RESTORE_FLAGS(NAMESPACE).
+#
+# AX_SAVE_FLAGS(mypackage)
+# CPPFLAGS="-Imypackagespath ${CPPFLAGS}"
+# dnl .. do some detection ...
+# AX_RESTORE_FLAGS(mypackage)
#
# LICENSE
#
# Copyright (c) 2009 Filippo Giunchedi <filippo@esaurito.net>
+# Copyright (c) 2011 The Board of Trustees of the Leland Stanford Junior University
+# Copyright (c) 2011 Russ Allbery <rra@stanford.edu>
+# Copyright (c) 2013 Bastien ROUCARIES <roucaries.bastien+autoconf@gmail.com>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 3
+#serial 7
+
+# list of flag to save
+AC_DEFUN([_AX_SAVE_FLAGS_LIST],[dnl
+[CCASFLAGS],dnl
+[CFLAGS],dnl
+[CPPFLAGS],dnl
+[CXXFLAGS],dnl
+[ERLCFLAGS],dnl
+[FCFLAGS],dnl
+[FCLIBS],dnl
+[FFLAGS],dnl
+[FLIBS],dnl
+[GCJFLAGS],dnl
+[JAVACFLAGS],dnl
+[LDFLAGS],dnl
+[LIBS],dnl
+[OBJCFLAGS],dnl
+[OBJCXXFLAGS],dnl
+[UPCFLAGS],dnl
+[VALAFLAGS]dnl
+])
+
+# save one flag in name space
+AC_DEFUN([_AX_SAVE_ONE_FLAG],[
+ AS_VAR_PUSHDEF([_ax_save_flag_var], [$2[]_$1[]_ax_save_flags])
+ AS_VAR_COPY(_ax_save_flag_var, $2[])
+ AS_VAR_POPDEF([_ax_save_flag_var])
+])
-AC_DEFUN([AX_SAVE_FLAGS], [
- CPPFLAGS_save="${CPPFLAGS}"
- CFLAGS_save="${CFLAGS}"
- CXXFLAGS_save="${CXXFLAGS}"
- OBJCFLAGS_save="${OBJCFLAGS}"
- LDFLAGS_save="${LDFLAGS}"
- LIBS_save="${LIBS}"
+AC_DEFUN([AX_SAVE_FLAGS],[dnl
+ m4_foreach([FLAG], dnl
+ [_AX_SAVE_FLAGS_LIST()], dnl
+ [_AX_SAVE_ONE_FLAG([$1],FLAG)])
])
# Cycle should always run first
tests_cycle_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING)
tests_cycle_CXXFLAGS= $(AM_CXXFLAGS)
-tests_cycle_CXXFLAGS+= ${PTHREAD_CFLAGS}
+tests_cycle_CXXFLAGS+= @PTHREAD_CFLAGS@
tests_cycle_SOURCES= tests/cycle.cc
tests_cycle_LDADD= $(TESTS_LDADDS)
-tests_cycle_LDADD+= ${PTHREAD_LIBS}
+tests_cycle_LDADD+= @PTHREAD_LIBS@
check_PROGRAMS+= tests/cycle
noinst_PROGRAMS+= tests/cycle
{"lp:1021819", true, (test_callback_fn*)regression_1021819_TEST },
{"lp:1048945", true, (test_callback_fn*)regression_1048945_TEST },
{"lp:1067242", true, (test_callback_fn*)regression_1067242_TEST },
+ {"lp:1251482", true, (test_callback_fn*)regression_bug_1251482 },
{0, false, (test_callback_fn*)0}
};
/* Put a retry timeout to effectively activate failure_limit effect */
test_compare(MEMCACHED_SUCCESS,
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1));
/* change behavior that triggers memcached_quit()*/
test_compare(MEMCACHED_SUCCESS,
return TEST_SUCCESS;
}
+test_return_t regression_bug_1251482(memcached_st*)
+{
+ test::Memc memc("--server=localhost:5");
+
+ memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 0);
+
+ for (size_t x= 4; x; --x)
+ {
+ size_t value_length;
+ memcached_return_t rc;
+ char *value= memcached_get(&memc,
+ test_literal_param(__func__),
+ &value_length, NULL, &rc);
+
+ test_false(value);
+ test_compare(0LLU, value_length);
+ test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
+ }
+
+ return TEST_SUCCESS;
+}
+
test_return_t regression_1009493_TEST(memcached_st*)
{
memcached_st* memc= memcached_create(NULL);
test_return_t regression_1048945_TEST(memcached_st*);
test_return_t regression_1067242_TEST(memcached_st*);
test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st*);
+test_return_t regression_bug_1251482(memcached_st*);
SKIP_UNLESS(libtest::has_libmemcached_sasl());
// Assume we are running under valgrind, and bail
- if (getenv("TESTS_ENVIRONMENT"))
+ if (getenv("LOG_COMPILER"))
{
error= TEST_SKIPPED;
return NULL;
static test_return_t init_udp_valgrind(memcached_st *memc)
{
- if (getenv("TESTS_ENVIRONMENT"))
+ if (getenv("LOG_COMPILER"))
{
return TEST_SKIPPED;
}
static test_return_t binary_init_udp(memcached_st *memc)
{
- if (getenv("TESTS_ENVIRONMENT"))
+ if (getenv("LOG_COMPILER"))
{
return TEST_SKIPPED;
}
static test_return_t udp_set_test(memcached_st *memc)
{
// Assume we are running under valgrind, and bail
- if (getenv("TESTS_ENVIRONMENT"))
+ if (getenv("LOG_COMPILER"))
{
return TEST_SUCCESS;
}
projects / m6w6 / libmemcached / commitdiff
