+ * Added Twitter's memcached_server_error() functions.
+ * Fix for OSX compiles in development builds.
+ * Updated C++ interface.
+
+0.31 Fri Jul 10 09:02:50 PDT 2009
+ * Added support or HA via replication.
+ * malloc() removed for server key usage.
+ * Update build system.
* Added support for memcached_set_memory_allocators().
* Fixed bug in configure.ac for have_htoll.
ACLOCAL_AMFLAGS = -I m4
-SUBDIRS = docs libmemcached libmemcachedutil tests support clients
+SUBDIRS = docs libmemcached libmemcachedutil support clients tests
EXTRA_dist = README.FIRST
check-local: test-no-outputdiff
-LDADDS = $(top_builddir)/libmemcached/libmemcached.la
+LDADDS = $(top_builddir)/libmemcached/libmemcached.la libutilities.la
bin_PROGRAMS = memcat memdump memcp memstat memrm memflush memslap memerror
generator.h \
execute.h
-memcat_SOURCES = memcat.c utilities.c
+noinst_LTLIBRARIES= libutilities.la libgenexec.la
+
+libutilities_la_SOURCES= utilities.c
+libgenexec_la_SOURCES= generator.c execute.c
+
+memcat_SOURCES = memcat.c
memcat_LDADD = $(LDADDS)
memcat_LDFLAGS = -rpath $(pkglibdir)
-memcp_SOURCES = memcp.c utilities.c
+memcp_SOURCES = memcp.c
memcp_LDADD = $(LDADDS)
memcp_LDFLAGS = -rpath $(pkglibdir)
-memdump_SOURCES = memdump.c utilities.c
+memdump_SOURCES = memdump.c
memdump_LDADD = $(LDADDS)
memdump_LDFLAGS = -rpath $(pkglibdir)
-memstat_SOURCES = memstat.c utilities.c
+memstat_SOURCES = memstat.c
memstat_LDADD = $(LDADDS)
memstat_LDFLAGS = -rpath $(pkglibdir)
-memrm_SOURCES = memrm.c utilities.c
+memrm_SOURCES = memrm.c
memrm_LDADD = $(LDADDS)
memrm_LDFLAGS = -rpath $(pkglibdir)
-memflush_SOURCES = memflush.c utilities.c
+memflush_SOURCES = memflush.c
memflush_LDADD = $(LDADDS)
memflush_LDFLAGS = -rpath $(pkglibdir)
-memerror_SOURCES = memerror.c utilities.c
+memerror_SOURCES = memerror.c
memerror_LDADD = $(LDADDS)
memerror_LDFLAGS = -rpath $(pkglibdir)
-memslap_SOURCES = memslap.c utilities.c generator.c execute.c
-memslap_LDADD = $(LDADDS) -lpthread
-memslap_LDFLAGS = -rpath $(pkglibdir)
+memslap_SOURCES = memslap.c
+memslap_CFLAGS = $(AM_CFLAGS) $(PTHREAD_CFLAGS)
+memslap_LDADD = $(LDADDS) $(PTHREAD_LIBS) libgenexec.la
+memslap_LDFLAGS = $(AM_LDFLAGS) -rpath $(pkglibdir)
test-start-server:
memflush --servers=localhost
if (opt_verbose)
{
- static char *opstr[] = { "set", "add", "replace" };
+ static const char *opstr[] = { "set", "add", "replace" };
printf("op: %s\nsource file: %s\nlength: %zu\n"
"key: %s\nflags: %x\nexpires: %llu\n",
opstr[opt_method - OPT_SET], argv[optind], (size_t)sbuf.st_size,
/* Prototypes */
static void options_parse(int argc, char *argv[]);
-static void run_analyzer(memcached_st *memc, memcached_stat_st *stat,
+static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat,
memcached_server_st *server_list);
-static void print_server_listing(memcached_st *memc, memcached_stat_st *stat,
+static void print_server_listing(memcached_st *memc, memcached_stat_st *memc_stat,
memcached_server_st *server_list);
static void print_analysis_report(memcached_st *memc,
memcached_analysis_st *report,
return s + us;
}
-void version_command(char *command_name)
+void version_command(const char *command_name)
{
printf("%s v%u.%u\n", command_name, 1, 0);
exit(0);
}
-static char *lookup_help(memcached_options option)
+static const char *lookup_help(memcached_options option)
{
switch (option)
{
return "forgot to document this function :)";
}
-void help_command(char *command_name, char *description,
+void help_command(const char *command_name, const char *description,
const struct option *long_options,
memcached_programs_help_st *options __attribute__((unused)))
{
for (x= 0; long_options[x].name; x++)
{
- char *help_message;
+ const char *help_message;
printf("\t --%s%c\n", long_options[x].name,
long_options[x].has_arg ? '=' : ' ');
char *strdup_cleanup(const char *str);
void cleanup(void);
long int timedif(struct timeval a, struct timeval b);
-void version_command(char *command_name);
-void help_command(char *command_name, char *description,
+void version_command(const char *command_name);
+void help_command(const char *command_name, const char *description,
const struct option *long_options,
memcached_programs_help_st *options);
void process_hash_option(memcached_st *memc, char *opt_hash);
-#!/usr/bin/env bash
+#!/bin/sh
# Taken from lighthttpd server (BSD). Thanks Jan!
# Run this to generate all the initial makefiles, etc.
die() { echo "$@"; exit 1; }
-# LIBTOOLIZE=${LIBTOOLIZE:-libtoolize}
+# --force means overwrite ltmain.sh script if it already exists
LIBTOOLIZE_FLAGS=" --automake --copy --force"
-# ACLOCAL=${ACLOCAL:-aclocal}
-ACLOCAL_FLAGS="-I m4"
-# AUTOHEADER=${AUTOHEADER:-autoheader}
-# AUTOMAKE=${AUTOMAKE:-automake}
+# --add-missing instructs automake to install missing auxiliary files
+# and --force to overwrite them if they already exist
AUTOMAKE_FLAGS="--add-missing --copy --force"
-# AUTOCONF=${AUTOCONF:-autoconf}
+ACLOCAL_FLAGS="-I m4"
ARGV0=$0
ARGS="$@"
-
run() {
echo "$ARGV0: running \`$@' $ARGS"
$@ $ARGS
}
-## jump out if one of the programs returns 'false'
-set -e
+# Try to locate a program by using which, and verify that the file is an
+# executable
+locate_binary() {
+ for f in $@
+ do
+ file=`which $f 2>/dev/null | grep -v '^no '`
+ if test -n "$file" -a -x "$file"; then
+ echo $file
+ return 0
+ fi
+ done
+
+ echo ""
+ return 1
+}
-## We do not currently support glibtoolize
+# Try to detect the supported binaries if the user didn't
+# override that by pushing the environment variable
if test x$LIBTOOLIZE = x; then
- if test \! "x`which glibtoolize 2> /dev/null | grep -v '^no'`" = x; then
- LIBTOOLIZE=glibtoolize
- elif test \! "x`which libtoolize-1.5 2> /dev/null | grep -v '^no'`" = x; then
- LIBTOOLIZE=libtoolize-1.5
- elif test \! "x`which libtoolize 2> /dev/null | grep -v '^no'`" = x; then
- LIBTOOLIZE=libtoolize
- else
- echo "libtoolize 1.5.x wasn't found, exiting"; exit 0
+ LIBTOOLIZE=`locate_binary glibtoolize libtoolize-1.5 libtoolize`
+ if test x$LIBTOOLIZE = x; then
+ die "Did not find a supported libtoolize"
fi
fi
-## suse has aclocal and aclocal-1.9
if test x$ACLOCAL = x; then
- if test \! "x`which aclocal-1.10 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal-1.10
- elif test \! "x`which aclocal-1.9 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal-1.9
- elif test \! "x`which aclocal19 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal19
- elif test \! "x`which aclocal 2> /dev/null | grep -v '^no'`" = x; then
- ACLOCAL=aclocal
- else
- echo "automake 1.9.x (aclocal) wasn't found, exiting"; exit 0
+ ACLOCAL=`locate_binary aclocal-1.10 aclocal-1.9 aclocal19 aclocal`
+ if test x$ACLOCAL = x; then
+ die "Did not find a supported aclocal"
fi
fi
if test x$AUTOMAKE = x; then
- if test \! "x`which automake-1.10 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake-1.10
- elif test \! "x`which automake-1.9 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake-1.9
- elif test \! "x`which automake19 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake19
- elif test \! "x`which automake 2> /dev/null | grep -v '^no'`" = x; then
- AUTOMAKE=automake
- else
- echo "automake 1.9.x wasn't found, exiting"; exit 0
+ AUTOMAKE=`locate_binary automake-1.10 automake-1.9 automake19 automake`
+ if test x$AUTOMAKE = x; then
+ die "Did not find a supported automake"
fi
fi
-
-## macosx has autoconf-2.59 and autoconf-2.60
if test x$AUTOCONF = x; then
- if test \! "x`which autoconf-2.59 2> /dev/null | grep -v '^no'`" = x; then
- AUTOCONF=autoconf-2.59
- elif test \! "x`which autoconf259 2> /dev/null | grep -v '^no'`" = x; then
- AUTOCONF=autoconf259
- elif test \! "x`which autoconf 2> /dev/null | grep -v '^no'`" = x; then
- AUTOCONF=autoconf
- else
- echo "autoconf 2.59+ wasn't found, exiting"; exit 0
+ AUTOCONF=`locate_binary autoconf-2.59 autoconf259 autoconf`
+ if test x$AUTOCONF = x; then
+ die "Did not find a supported autoconf"
fi
fi
if test x$AUTOHEADER = x; then
- if test \! "x`which autoheader-2.59 2> /dev/null | grep -v '^no'`" = x; then
- AUTOHEADER=autoheader-2.59
- elif test \! "x`which autoheader259 2> /dev/null | grep -v '^no'`" = x; then
- AUTOHEADER=autoheader259
- elif test \! "x`which autoheader 2> /dev/null | grep -v '^no'`" = x; then
- AUTOHEADER=autoheader
- else
- echo "autoconf 2.59+ (autoheader) wasn't found, exiting"; exit 0
+ AUTOHEADER=`locate_binary autoheader-2.59 autoheader259 autoheader`
+ if test x$AUTOHEADER = x; then
+ die "Did not find a supported autoheader"
fi
fi
-
-# --force means overwrite ltmain.sh script if it already exists
run $LIBTOOLIZE $LIBTOOLIZE_FLAGS || die "Can't execute libtoolize"
-
run $ACLOCAL $ACLOCAL_FLAGS || die "Can't execute aclocal"
run $AUTOHEADER || die "Can't execute autoheader"
-
-# --add-missing instructs automake to install missing auxiliary files
-# and --force to overwrite them if they already exist
run $AUTOMAKE $AUTOMAKE_FLAGS || die "Can't execute automake"
run $AUTOCONF || die "Can't execute autoconf"
-echo -n "Automade with: "
-$AUTOMAKE --version | head -1
-echo -n "Configured with: "
-$AUTOCONF --version | head -1
-
+echo "---"
+echo "Configured with the following tools:"
+echo " * `$LIBTOOLIZE --version | head -1`"
+echo " * `$ACLOCAL --version | head -1`"
+echo " * `$AUTOHEADER --version | head -1`"
+echo " * `$AUTOMAKE --version | head -1`"
+echo " * `$AUTOCONF --version | head -1`"
+echo "---"
# libmemcached
-# Copyright (C) 2008 Brian Aker
+# Copyright (C) 2008 Brian Aker, Monty Taylor
# All rights reserved.
#
# Use and distribution licensed under the BSD license. See
# the COPYING file in this directory for full text.
AC_PREREQ(2.59)
-AC_INIT([libmemcached],[0.30],[http://tangent.org/552/libmemcached.html])
+AC_INIT([libmemcached],[0.31],[http://tangent.org/552/libmemcached.html])
AC_CONFIG_SRCDIR([libmemcached/memcached.c])
AC_CONFIG_AUX_DIR(config)
-AM_CONFIG_HEADER(libmemcached/libmemcached_config.h)
+AM_CONFIG_HEADER([config.h])
AC_CONFIG_MACRO_DIR([m4])
+PANDORA_CANONICAL_TARGET
+
#shared library versioning
MEMCACHED_LIBRARY_VERSION=2:0:0
# | | |
MEMCACHEDUTIL_LIBRARY_VERSION=0:0:0
AC_SUBST(MEMCACHEDUTIL_LIBRARY_VERSION)
-# Setting CFLAGS here prevents AC_CANONICAL_TARGET from injecting them
-SAVE_CFLAGS=${CFLAGS}
-SAVE_CXXFLAGS=${CXXFLAGS}
-CFLAGS=
-CXXFLAGS=
-
-AC_CANONICAL_TARGET
-
-CFLAGS=${SAVE_CFLAGS}
-CXXFLAGS=${SAVE_CXXFLAGS}
-
-AM_INIT_AUTOMAKE([-Wall -Werror nostdinc subdir-objects])
-
-if test "x${enable_dependency_tracking}" = "x"
-then
- enable_dependency_tracking=yes
-fi
-
-if test -d "${srcdir}/.bzr"
-then
- building_from_bzr=yes
-else
- building_from_bzr=no
-fi
-
-AC_PROG_CXX
-
-ACX_USE_SYSTEM_EXTENSIONS
-
-AC_PROG_CPP
-AM_PROG_CC_C_O
-
-FORCE_MAC_GCC42
-dnl Once we can use a modern autoconf, we can use this
-dnl AC_PROG_CC_C99
-
-AC_C_BIGENDIAN
-AC_C_CONST
-AC_HEADER_TIME
-AC_TYPE_SIZE_T
-AC_FUNC_MALLOC
-AC_FUNC_REALLOC
-
-AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])
-
-# We use libtool
-AC_PROG_LIBTOOL
-
-AC_MSG_CHECKING("C Compiler version")
-if test "$GCC" = "yes"
-then
- CC_VERSION=`$CC --version | sed 1q`
-elif test "$SUNCC" = "yes"
-then
- CC_VERSION=`$CC -V 2>&1 | sed 1q`
-else
- CC_VERSION=""
-fi
-AC_MSG_RESULT("$CC_VERSION")
-AC_SUBST(CC_VERSION)
# libmemcached versioning when linked with GNU ld.
if test "$lt_cv_prog_gnu_ld" = "yes"
AC_SUBST(LD_VERSION_SCRIPT)
AC_SUBST(LD_UTIL_VERSION_SCRIPT)
-# Build optimized or debug version ?
-# First check for gcc and g++
-if test "$GCC" = "yes"
-then
-
- dnl Once we can use a modern autoconf, we can replace the std=gnu99 here
- dnl with using AC_CC_STD_C99 above
- CC="${CC} -std=gnu99"
-
- CFLAGS="-ggdb3 ${CFLAGS}"
- CXXFLAGS="-ggdb3 ${CXXFLAGS}"
-
- DEBUG_CFLAGS="-O0"
- DEBUG_CXXFLAGS="-O0"
-
- OPTIMIZE_CFLAGS="-O3"
- OPTIMIZE_CXXFLAGS="-O3"
-fi
-if test "x$SUNCC" = "xyes"
-then
- dnl Once we can use a modern autoconf, we can replace the -xc99=all here
- dnl with using AC_CC_STD_C99 above
- CC="${CC} -xc99=all"
-
- CFLAGS="-g -mt ${CFLAGS}"
- CXXFLAGS="-xlang=c99 -g -mt -compat=5 -library=stlport4 -template=no%extdef ${CXXFLAGS}"
-
- OPTIMIZE_FLAGS="-xO4 -xlibmil -xdepend -xbuiltin"
- OPTIMIZE_CFLAGS="${OPTIMIZE_FLAGS} -Xa -xstrconst"
- OPTIMIZE_CXXFLAGS="${OPTIMIZE_FLAGS}"
-
-fi
-
-ENABLE_64BIT
#--------------------------------------------------------------------
# Check for libpthread
dnl Specialty checks
DETECT_BYTEORDER
ENABLE_UTILLIB
-ENABLE_DTRACE
SETSOCKOPT_SANITY
ENABLE_HSIEH_HASH
REQUIRE_POD2MAN
WITH_MEMCACHED
ENABLE_DEPRECATED
-dnl TODO: Remove this define once we are using 2.61 across the board.
-# AX_HEADER_ASSERT
-# ----------------
-# Check whether to enable assertions.
-AC_DEFUN([AX_HEADER_ASSERT],
-[
- AC_MSG_CHECKING([whether to enable assertions])
- AC_ARG_ENABLE([assert],
- [AS_HELP_STRING([--disable-assert],
- [Turn off assertions])],
- [ac_cv_assert="no"],
- [ac_cv_assert="yes"])
- AC_MSG_RESULT([$ac_cv_assert])
-])
-AX_HEADER_ASSERT
-
-
-AC_ARG_WITH([debug],
- [AS_HELP_STRING([--with-debug],
- [Add debug code/turns off optimizations (yes|no) @<:@default=no@:>@])],
- [with_debug=$withval],
- [with_debug=no])
-if test "$with_debug" = "yes"
-then
- # Debugging. No optimization.
- CFLAGS="${DEBUG_CFLAGS} -DDEBUG ${CFLAGS}"
- CXXFLAGS="${DEBUG_CXXFLAGS} -DDEBUG ${CXXFLAGS}"
-else
- # Optimized version. No debug
- CFLAGS="${OPTIMIZE_CFLAGS} ${CFLAGS}"
- CXXFLAGS="${OPTIMIZE_CXXFLAGS} ${CXXFLAGS}"
-fi
-
-AC_ARG_ENABLE([profiling],
- [AS_HELP_STRING([--enable-profiling],
- [Toggle profiling @<:@default=off@:>@])],
- [ac_profiling="$enableval"],
- [ac_profiling="no"])
-
-AC_ARG_ENABLE([coverage],
- [AS_HELP_STRING([--enable-coverage],
- [Toggle coverage @<:@default=off@:>@])],
- [ac_coverage="$enableval"],
- [ac_coverage="no"])
-
-if test "$GCC" = "yes"
-then
-
- AC_CACHE_CHECK([whether it is safe to use -fdiagnostics-show-option],
- [ac_cv_safe_to_use_fdiagnostics_show_option_],
- [save_CFLAGS="$CFLAGS"
- CFLAGS="-fdiagnostics-show-option ${CFLAGS}"
- AC_COMPILE_IFELSE(
- [AC_LANG_PROGRAM([],[])],
- [ac_cv_safe_to_use_fdiagnostics_show_option_=yes],
- [ac_cv_safe_to_use_fdiagnostics_show_option_=no])
- CFLAGS="$save_CFLAGS"])
-
- AS_IF([test "$ac_cv_safe_to_use_fdiagnostics_show_option_" = "yes"],
- [
- F_DIAGNOSTICS_SHOW_OPTION="-fdiagnostics-show-option"
- ])
-
- AC_CACHE_CHECK([whether it is safe to use -Wconversion],
- [ac_cv_safe_to_use_wconversion_],
- [save_CFLAGS="$CFLAGS"
- CFLAGS="-Werror -Wconversion ${CFLAGS}"
- AC_COMPILE_IFELSE(
- [AC_LANG_PROGRAM([[
-#include <stdbool.h>
-void foo(bool a)
-{
- (void)a;
-}
- ]],[[
-foo(0);
- ]])],
- [ac_cv_safe_to_use_wconversion_=yes],
- [ac_cv_safe_to_use_wconversion_=no])
- CFLAGS="$save_CFLAGS"])
-
- AS_IF([test "$ac_cv_safe_to_use_wconversion_" = "yes"],
- [W_CONVERSION="-Wconversion"
- AC_CACHE_CHECK([whether it is safe to use -Wconversion with htons],
- [ac_cv_safe_to_use_Wconversion_],
- [save_CFLAGS="$CFLAGS"
- CFLAGS="-Werror -Wconversion ${CFLAGS}"
- AC_COMPILE_IFELSE(
- [AC_LANG_PROGRAM(
- [[
-#include <netinet/in.h>
- ]],[[
-uint16_t x= htons(80);
- ]])],
- [ac_cv_safe_to_use_Wconversion_=yes],
- [ac_cv_safe_to_use_Wconversion_=no])
- CFLAGS="$save_CFLAGS"])
-
- AS_IF([test "$ac_cv_safe_to_use_Wconversion_" = "no"],
- [
- NO_CONVERSION="-Wno-conversion"
- ])
- ])
-
- AS_IF([test "$ac_profiling" = "yes"],
- [CC_PROFILING="-pg"])
-
- AS_IF([test "$ac_coverage" = "yes"],
- [CC_COVERAGE="-fprofile-arcs -ftest-coverage"])
-
- AS_IF([test "$building_from_bzr" = "yes"],
- [W_FAIL="-Werror"])
-
- BASE_WARNINGS="-pedantic -Wall -Wextra ${W_FAIL} -Wundef -Wshadow -Wmissing-declarations -Wstrict-aliasing -Wformat=2 ${F_DIAGNOSTICS_SHOW_OPTION} ${W_CONVERSION}"
- CC_WARNINGS="${BASE_WARNINGS} -Wstrict-prototypes -Wmissing-prototypes -Wredundant-decls -Wswitch-default -Wswitch-enum -Wcast-align"
- CXX_WARNINGS="${BASE_WARNINGS} -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wold-style-cast -Weffc++ -Wno-long-long"
-
- AC_CACHE_CHECK([whether it is safe to use -Wlogical-op],
- [ac_cv_safe_to_use_Wlogical_op_],
- [save_CFLAGS="$CFLAGS"
- CFLAGS="-Wlogical-op"
- AC_COMPILE_IFELSE([
- AC_LANG_PROGRAM(
- [[
-#include <stdio>
- ]], [[]])
- ],
- [ac_cv_safe_to_use_Wlogical_op_=yes],
- [ac_cv_safe_to_use_Wlogical_op_=no])
- CFLAGS="$save_CFLAGS"])
- AS_IF([test "$ac_cv_safe_to_use_Wlogical_op_" = "yes"],
- [CC_WARNINGS="${CC_WARNINGS} -Wlogical-op"])
-
- AC_CACHE_CHECK([whether it is safe to use -Wredundant-decls from C++],
- [ac_cv_safe_to_use_Wredundant_decls_],
- [AC_LANG_PUSH(C++)
- save_CXXFLAGS="${CXXFLAGS}"
- CXXFLAGS="${CXXFLAGS} ${W_FAIL} -Wredundant-decls"
- AC_COMPILE_IFELSE(
- [AC_LANG_PROGRAM([
-template <typename E> struct C { void foo(); };
-template <typename E> void C<E>::foo() { }
-template <> void C<int>::foo();
- AC_INCLUDES_DEFAULT])],
- [ac_cv_safe_to_use_Wredundant_decls_=yes],
- [ac_cv_safe_to_use_Wredundant_decls_=no])
- CXXFLAGS="${save_CXXFLAGS}"
- AC_LANG_POP()])
- AS_IF([test "$ac_cv_safe_to_use_Wredundant_decls_" = "yes"],
- [CXX_WARNINGS="${CXX_WARNINGS} -Wredundant-decls"],
- [CXX_WARNINGS="${CXX_WARNINGS} -Wno-redundant-decls"])
-
- NO_REDUNDANT_DECLS="-Wno-redundant-decls"
-fi
-if test "$SUNCC" = "yes"
-then
-
- AS_IF([test "$ac_profiling" = "yes"],
- [CC_PROFILING="-xinstrument=datarace"])
-
- AS_IF([test "$building_from_bzr" = "yes"],
- [W_FAIL="-errwarn=%all"])
-
- AC_CACHE_CHECK([whether E_PASTE_RESULT_NOT_TOKEN is usable],
- [ac_cv_paste_result],
- [
- save_CFLAGS="${CFLAGS}"
- CFLAGS="-errwarn=%all -erroff=E_PASTE_RESULT_NOT_TOKEN ${CFLAGS}"
- AC_COMPILE_IFELSE(
- [AC_LANG_PROGRAM([
- AC_INCLUDES_DEFAULT
- ],[
- int x= 0;])],
- [ac_cv_paste_result=yes],
- [ac_cv_paste_result=no])
- CFLAGS="${save_CFLAGS}"
- ])
- AS_IF([test $ac_cv_paste_result = yes],
- [W_PASTE_RESULT=",E_PASTE_RESULT_NOT_TOKEN"])
-
-
- CC_WARNINGS="-v -errtags=yes ${W_FAIL} -erroff=E_INTEGER_OVERFLOW_DETECTED${W_PASTE_RESULT}"
- CXX_WARNINGS="+w +w2 -xwe -xport64 -errtags=yes ${W_FAIL}"
-fi
-
-AC_SUBST(NO_CONVERSION)
-AC_SUBST(NO_REDUNDANT_DECLS)
-
-AM_CPPFLAGS="-I\$(top_srcdir) -I\$(top_builddir) ${CPPFLAGS}"
-AM_CFLAGS="${CC_WARNINGS} ${CC_PROFILING} ${CC_COVERAGE} ${CFLAGS}"
-AM_CXXFLAGS="${CXX_WARNING} ${CC_PROFILING} ${CC_COVERAGE} ${CXXFLAGS}"
-
-AC_SUBST([AM_CPPFLAGS])
-AC_SUBST([AM_CFLAGS])
-AC_SUBST([AM_CXXFLAGS])
-
-dnl We've collected the flags in AM_*FLAGS now, so blank these.
-CFLAGS=""
-CXXFLAGS=""
-CPPFLAGS=""
AC_CONFIG_FILES([
Makefile
echo " * C Compiler: $CC_VERSION"
echo " * Assertions enabled: $ac_cv_assert"
echo " * Debug enabled: $with_debug"
-echo " * Warnings as failure: $building_from_bzr"
+echo " * Warnings as failure: $ac_cv_warnings_as_errors"
echo ""
echo "---"
memcached_analyze.pod\
memcached_generate_hash_value.pod\
memcached_memory_allocators.pod\
- memory_user_data.pod
+ memcached_user_data.pod
man_MANS = libmemcached.3\
libmemcached_examples.3\
=head1 NAME
-memcached_set_memory_allocators, memcached_get_memory_allocators
+memcached_set_memory_allocators, memcached_get_memory_allocators - Manage memory allocator functions
=head1 LIBRARY
memcached_server_st *memcached_servers_parse (const char *server_strings);
+ const char *memcached_server_error(memcached_server_st *ptr);
+
+ void memcached_server_error_reset(memcached_server_st *ptr);
+
=head1 DESCRIPTION
libmemcached(3) operates on a list of hosts which are stored in
The example is "localhost, foo:555, foo, bar". All hosts except foo:555 will
be set to the default port, while that host will have a port of 555.
+memcached_server_error() can be used to look at the text of the last error
+message sent by the server to to the client. Use memcached_server_error_reset()
+to reset the message (this does not currently free up the memory associated
+with the message).
+
+
=head1 RETURN
Varies, see particular functions.
=head1 NAME
-memcached_set_user_data, memcached_get_user_data
+memcached_set_user_data, memcached_get_user_data - Manage user specific data
=head1 LIBRARY
EXTRA_DIST = libmemcached_probes.d memcached/README.txt libmemcached.ver \
memcached_configure.h.in
-BUILT_SOURCES= @DTRACE_HEADER@
-
EXTRA_HEADERS =
-DTRACE = @DTRACE@
-DTRACEFLAGS = @DTRACEFLAGS@
+BUILT_SOURCES=
noinst_HEADERS = libmemcached_probes.h \
- libmemcached_config.h \
- memcached_io.h \
+ memcached_io.h \
memcached_internal.h \
common.h \
- memcached/protocol_binary.h @DTRACE_HEADER@
+ memcached/protocol_binary.h
pkginclude_HEADERS= memcached.h \
memcached.hh \
+ memcached_configure.h \
memcached_constants.h \
memcached_get.h \
memcached_result.h \
memcached_storage.h \
memcached_string.h \
memcached_types.h \
- memcached_watchpoint.h
+ memcached_watchpoint.h \
+ visibility.h
+
if BUILD_LIBMEMCACHEDUTIL
pkginclude_HEADERS+= memcached_util.h memcached_pool.h
endif
lib_LTLIBRARIES = libmemcached.la
+noinst_LTLIBRARIES = libmemcachedcallbacks.la
+libmemcachedcallbacks_la_CFLAGS = ${AM_CFLAGS} ${NO_STRICT_ALIASING}
+libmemcachedcallbacks_la_SOURCES = memcached_callback.c
libmemcached_la_CFLAGS= ${AM_CFLAGS} ${NO_CONVERSION}
libmemcached_la_SOURCES = crc.c \
memcached_auto.c \
memcached_analyze.c \
memcached_behavior.c \
- memcached_callback.c \
memcached_connect.c \
memcached_delete.c \
memcached_do.c \
jenkins_hash.c \
memcached_allocators.c
+
if INCLUDE_HSIEH_SRC
libmemcached_la_SOURCES += hsieh_hash.c
endif
libmemcached_la_SOURCES += byteorder.c
endif
-DEFS += -DMEMCACHED_INTERNAL
-libmemcached_la_DEPENDENCIES = @DTRACE_OBJ@
-libmemcached_la_LIBADD = @DTRACE_OBJ@ $(LIBM)
+libmemcached_la_DEPENDENCIES= libmemcachedcallbacks.la
+libmemcached_la_LIBADD= $(LIBM) libmemcachedcallbacks.la
libmemcached_la_LDFLAGS = -version-info $(MEMCACHED_LIBRARY_VERSION) $(LD_VERSION_SCRIPT) $(LIBM)
-dtrace_probes.h: libmemcached_probes.d
- $(DTRACE) $(DTRACEFLAGS) -o dtrace_probes.tmp -h -s libmemcached_probes.d
- sed "s/#include <unistd.h>//g" dtrace_probes.tmp > dtrace_probes.h
- rm dtrace_probes.tmp
+if HAVE_DTRACE
+BUILT_SOURCES+= dtrace_probes.h
+libmemcached_la_SOURCES += libmemcached_probes.d
+endif
+
+if DTRACE_NEEDS_OBJECTS
+libmemcached_la_DEPENDENCIES += libmemcached_probes.o
+endif
+SUFFIXES= .d
-# So libtool doesn't support dtrace, but just copy one of the existing
-# lo-file and replace the file name ;-)
-libmemcached_probes.lo: libmemcached_probes.o
- sed "s,jenkins_hash,libmemcached_probes,g" jenkins_hash.lo > libmemcached_probes.lo
+dtrace_probes.h: libmemcached_probes.d
+ $(DTRACE) $(DTRACEFLAGS) -h -o dtrace_probes.h -s libmemcached_probes.d
-libmemcached_probes.o: $(libmemcached_la_OBJECTS)
- $(DTRACE) $(DTRACEFLAGS) -o .libs/libmemcached_probes.o -G -s libmemcached_probes.d `grep pic_object *.lo | cut -f 2 -d\' | grep -v non_pic_object`
+libmemcached_probes.o: libmemcached_probes.d $(libmemcached_la_OBJECTS)
+ $(DTRACE) $(DTRACEFLAGS) -o .libs/libmemcached_probes.o -G -s libmemcached_probes.d `grep '^pic_object' *.lo | cut -f 2 -d\'`
$(DTRACE) $(DTRACEFLAGS) -o libmemcached_probes.o -G -s libmemcached_probes.d `grep non_pic_object *.lo | cut -f 2 -d\' `
Common include file for libmemached
*/
-#ifndef __COMMON_H__
-#define __COMMON_H__
+#ifndef LIBMEMCACHED_COMMON_H
+#define LIBMEMCACHED_COMMON_H
-#include "libmemcached/libmemcached_config.h"
+#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/un.h>
#include <netinet/tcp.h>
-
-
-#include "libmemcached/memcached.h"
-#include "libmemcached/memcached_io.h"
-
-#include "libmemcached/memcached/protocol_binary.h"
-
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
# endif
#endif
+/* Define this here, which will turn on the visibilty controls while we're
+ * building libmemcached.
+ */
+#define BUILDING_LIBMEMCACHED 1
+
+
+#include "libmemcached/memcached.h"
+#include "libmemcached/memcached_watchpoint.h"
+
+/* These are private not to be installed headers */
+#include "libmemcached/memcached_io.h"
+#include "libmemcached/memcached_internal.h"
+#include "libmemcached/libmemcached_probes.h"
+#include "libmemcached/memcached/protocol_binary.h"
+
+/* string value */
+struct memcached_continuum_item_st {
+ uint32_t index;
+ uint32_t value;
+};
#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
#define unlikely(x) if(__builtin_expect((x), 0))
#endif
-#include "libmemcached_probes.h"
#define MEMCACHED_BLOCK_SIZE 1024
#define MEMCACHED_DEFAULT_COMMAND_SIZE 350
} memcached_flags;
/* Hashing algo */
+
+LIBMEMCACHED_LOCAL
void md5_signature(const unsigned char *key, unsigned int length, unsigned char *result);
+LIBMEMCACHED_LOCAL
uint32_t hash_crc32(const char *data,
size_t data_len);
#ifdef HAVE_HSIEH_HASH
+LIBMEMCACHED_LOCAL
uint32_t hsieh_hash(const char *key, size_t key_length);
#endif
+LIBMEMCACHED_LOCAL
uint32_t murmur_hash(const char *key, size_t key_length);
+LIBMEMCACHED_LOCAL
uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval);
+LIBMEMCACHED_LOCAL
memcached_return memcached_connect(memcached_server_st *ptr);
+LIBMEMCACHED_LOCAL
memcached_return memcached_response(memcached_server_st *ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result);
+LIBMEMCACHED_LOCAL
void memcached_quit_server(memcached_server_st *ptr, uint8_t io_death);
#define memcached_server_response_increment(A) (A)->cursor_active++
#define memcached_server_response_decrement(A) (A)->cursor_active--
#define memcached_server_response_reset(A) (A)->cursor_active=0
+LIBMEMCACHED_LOCAL
memcached_return memcached_do(memcached_server_st *ptr, const void *commmand,
size_t command_length, uint8_t with_flush);
-memcached_return memcached_version(memcached_st *ptr);
+LIBMEMCACHED_LOCAL
memcached_return value_fetch(memcached_server_st *ptr,
char *buffer,
memcached_result_st *result);
+LIBMEMCACHED_LOCAL
void server_list_free(memcached_st *ptr, memcached_server_st *servers);
-memcached_return memcached_key_test(char **keys, size_t *key_length,
+LIBMEMCACHED_LOCAL
+memcached_return memcached_key_test(const char **keys, size_t *key_length,
unsigned int number_of_keys);
-memcached_return run_distribution(memcached_st *ptr);
+LIBMEMCACHED_LOCAL
uint32_t generate_hash(memcached_st *ptr, const char *key, size_t key_length);
-memcached_return memcached_server_remove(memcached_server_st *st_ptr);
#ifndef HAVE_HTONLL
+LIBMEMCACHED_LOCAL
extern uint64_t ntohll(uint64_t);
+LIBMEMCACHED_LOCAL
extern uint64_t htonll(uint64_t);
#endif
+LIBMEMCACHED_LOCAL
memcached_return memcached_purge(memcached_server_st *ptr);
static inline memcached_return memcached_validate_key_length(size_t key_length,
return MEMCACHED_SUCCESS;
}
-#endif /* __COMMON_H__ */
+#endif /* LIBMEMCACHED_COMMON_H */
provider libmemcached {
probe memcached_delete_start();
probe memcached_delete_end();
+ probe memcached_increment_with_initial_start();
+ probe memcached_increment_with_initial_end();
+ probe memcached_decrement_with_initial_start();
+ probe memcached_decrement_with_initial_end();
probe memcached_increment_start();
probe memcached_increment_end();
probe memcached_decrement_start();
#include <sys/types.h>
#include <netinet/in.h>
-#ifdef MEMCACHED_INTERNAL
-#include <libmemcached/libmemcached_config.h>
-#endif
+#include <libmemcached/visibility.h>
#include <libmemcached/memcached_configure.h>
#include <libmemcached/memcached_constants.h>
#include <libmemcached/memcached_types.h>
-#include <libmemcached/memcached_watchpoint.h>
#include <libmemcached/memcached_get.h>
#include <libmemcached/memcached_server.h>
#include <libmemcached/memcached_string.h>
#include <libmemcached/memcached_result.h>
+#include <libmemcached/memcached_storage.h>
#ifdef __cplusplus
extern "C" {
#endif
-/* These are Private and should not be used by applications */
#define MEMCACHED_VERSION_STRING_LENGTH 24
-
-/* string value */
-struct memcached_continuum_item_st {
- uint32_t index;
- uint32_t value;
-};
-
-#define LIBMEMCACHED_VERSION_STRING "0.30"
+#define LIBMEMCACHED_VERSION_STRING "0.31"
struct memcached_analysis_st {
uint32_t average_item_size;
uint32_t number_of_replicas;
};
+LIBMEMCACHED_API
+memcached_return memcached_version(memcached_st *ptr);
/* Public API */
+
+LIBMEMCACHED_API
const char * memcached_lib_version(void);
+LIBMEMCACHED_API
memcached_st *memcached_create(memcached_st *ptr);
+LIBMEMCACHED_API
void memcached_free(memcached_st *ptr);
+LIBMEMCACHED_API
memcached_st *memcached_clone(memcached_st *clone, memcached_st *ptr);
+LIBMEMCACHED_API
memcached_return memcached_delete(memcached_st *ptr, const char *key, size_t key_length,
time_t expiration);
+LIBMEMCACHED_API
memcached_return memcached_increment(memcached_st *ptr,
const char *key, size_t key_length,
uint32_t offset,
uint64_t *value);
+LIBMEMCACHED_API
memcached_return memcached_decrement(memcached_st *ptr,
const char *key, size_t key_length,
uint32_t offset,
uint64_t *value);
+LIBMEMCACHED_API
memcached_return memcached_increment_with_initial(memcached_st *ptr,
const char *key,
size_t key_length,
uint64_t initial,
time_t expiration,
uint64_t *value);
+LIBMEMCACHED_API
memcached_return memcached_decrement_with_initial(memcached_st *ptr,
const char *key,
size_t key_length,
uint64_t initial,
time_t expiration,
uint64_t *value);
+LIBMEMCACHED_API
void memcached_stat_free(memcached_st *, memcached_stat_st *);
+LIBMEMCACHED_API
memcached_stat_st *memcached_stat(memcached_st *ptr, char *args, memcached_return *error);
-memcached_return memcached_stat_servername(memcached_stat_st *stat, char *args,
+LIBMEMCACHED_API
+memcached_return memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
char *hostname, unsigned int port);
+LIBMEMCACHED_API
memcached_return memcached_flush(memcached_st *ptr, time_t expiration);
+LIBMEMCACHED_API
memcached_return memcached_verbosity(memcached_st *ptr, unsigned int verbosity);
+LIBMEMCACHED_API
void memcached_quit(memcached_st *ptr);
-char *memcached_strerror(memcached_st *ptr, memcached_return rc);
+LIBMEMCACHED_API
+const char *memcached_strerror(memcached_st *ptr, memcached_return rc);
+LIBMEMCACHED_API
memcached_return memcached_behavior_set(memcached_st *ptr, memcached_behavior flag, uint64_t data);
+LIBMEMCACHED_API
uint64_t memcached_behavior_get(memcached_st *ptr, memcached_behavior flag);
/* The two public hash bits */
+LIBMEMCACHED_API
uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash hash_algorithm);
+LIBMEMCACHED_API
uint32_t memcached_generate_hash(memcached_st *ptr, const char *key, size_t key_length);
+LIBMEMCACHED_API
memcached_return memcached_flush_buffers(memcached_st *mem);
/* Server Public functions */
+LIBMEMCACHED_API
memcached_return memcached_server_add_udp(memcached_st *ptr,
const char *hostname,
unsigned int port);
+LIBMEMCACHED_API
memcached_return memcached_server_add_unix_socket(memcached_st *ptr,
const char *filename);
+LIBMEMCACHED_API
memcached_return memcached_server_add(memcached_st *ptr, const char *hostname,
unsigned int port);
+LIBMEMCACHED_API
memcached_return memcached_server_add_udp_with_weight(memcached_st *ptr,
const char *hostname,
unsigned int port,
uint32_t weight);
+LIBMEMCACHED_API
memcached_return memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
const char *filename,
uint32_t weight);
+LIBMEMCACHED_API
memcached_return memcached_server_add_with_weight(memcached_st *ptr, const char *hostname,
unsigned int port,
uint32_t weight);
+LIBMEMCACHED_API
void memcached_server_list_free(memcached_server_st *ptr);
+LIBMEMCACHED_API
memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list);
+LIBMEMCACHED_API
memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
const char *hostname,
unsigned int port,
memcached_return *error);
+LIBMEMCACHED_API
memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
const char *hostname,
unsigned int port,
uint32_t weight,
memcached_return *error);
+LIBMEMCACHED_API
unsigned int memcached_server_list_count(memcached_server_st *ptr);
+LIBMEMCACHED_API
memcached_server_st *memcached_servers_parse(const char *server_strings);
-char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *stat,
+LIBMEMCACHED_API
+char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *memc_stat,
const char *key, memcached_return *error);
-char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *stat,
+LIBMEMCACHED_API
+char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *memc_stat,
memcached_return *error);
+LIBMEMCACHED_API
memcached_return memcached_delete_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
time_t expiration);
+LIBMEMCACHED_API
memcached_return memcached_fetch_execute(memcached_st *ptr,
memcached_execute_function *callback,
void *context,
unsigned int number_of_callbacks);
+LIBMEMCACHED_API
memcached_return memcached_callback_set(memcached_st *ptr,
memcached_callback flag,
void *data);
+LIBMEMCACHED_API
void *memcached_callback_get(memcached_st *ptr,
memcached_callback flag,
memcached_return *error);
+LIBMEMCACHED_API
memcached_return memcached_dump(memcached_st *ptr, memcached_dump_func *function, void *context, uint32_t number_of_callbacks);
+LIBMEMCACHED_API
memcached_return memcached_set_memory_allocators(memcached_st *ptr,
memcached_malloc_function mem_malloc,
memcached_free_function mem_free,
memcached_realloc_function mem_realloc,
memcached_calloc_function mem_calloc);
+LIBMEMCACHED_API
void memcached_get_memory_allocators(memcached_st *ptr,
memcached_malloc_function *mem_malloc,
memcached_free_function *mem_free,
memcached_realloc_function *mem_realloc,
memcached_calloc_function *mem_calloc);
+LIBMEMCACHED_API
void *memcached_get_user_data(memcached_st *ptr);
+LIBMEMCACHED_API
void *memcached_set_user_data(memcached_st *ptr, void *data);
+LIBMEMCACHED_API
+memcached_return run_distribution(memcached_st *ptr);
#ifdef __cplusplus
}
#endif
-#include <libmemcached/memcached_storage.h>
-
-#ifdef MEMCACHED_INTERNAL
-#include <libmemcached/memcached_internal.h>
-#endif
#endif /* __MEMCACHED_H__ */
-#include "libmemcached/memcached.h"
-#include <string.h>
-#include <stdio.h>
+#include <libmemcached/memcached.h>
+
+#include <string>
+#include <vector>
class Memcached
{
- memcached_st memc;
- memcached_result_st result;
-
public:
- Memcached() : memc(), result()
+ Memcached()
+ :
+ memc(),
+ result()
{
memcached_create(&memc);
}
- Memcached(memcached_st *clone) : memc(), result()
+ Memcached(memcached_st *clone)
+ :
+ memc(),
+ result()
{
memcached_clone(&memc, clone);
}
- char *fetch (char *key, size_t *key_length, size_t *value_length)
+
+ ~Memcached()
{
- uint32_t flags;
- memcached_return rc;
+ memcached_free(&memc);
+ }
- return memcached_fetch(&memc, key, key_length,
- value_length, &flags, &rc);
+ bool fetch(std::string &key,
+ std::string &ret_val,
+ size_t *key_length,
+ size_t *value_length,
+ uint32_t *flags,
+ memcached_return *rc)
+ {
+ char ret_key[MEMCACHED_MAX_KEY];
+ char *value= memcached_fetch(&memc, ret_key, key_length,
+ value_length, flags, rc);
+ if (value)
+ {
+ ret_val.assign(value);
+ key.assign(ret_key);
+ return true;
+ }
+ return false;
}
- char *get(const char *key, size_t *value_length)
+
+ std::string get(const std::string &key, size_t *value_length)
{
uint32_t flags;
memcached_return rc;
+ std::string ret_val;
- return memcached_get(&memc, key, strlen(key),
- value_length, &flags, &rc);
+ char *value= memcached_get(&memc, key.c_str(), key.length(),
+ value_length, &flags, &rc);
+ if (value)
+ {
+ ret_val.assign(value);
+ }
+ return ret_val;
}
- char *get_by_key(const char *master_key, const char *key,
- size_t *value_length)
+ std::string get_by_key(const std::string &master_key,
+ const std::string &key,
+ size_t *value_length)
{
uint32_t flags;
memcached_return rc;
+ std::string ret_val;
- return memcached_get_by_key(&memc, master_key, strlen(master_key),
- key, strlen(key),
- value_length, &flags, &rc);
+ char *value= memcached_get_by_key(&memc, master_key.c_str(), master_key.length(),
+ key.c_str(), key.length(),
+ value_length, &flags, &rc);
+ if (value)
+ {
+ ret_val.assign(value);
+ }
+ return ret_val;
}
- memcached_return mget(char **keys, size_t *key_length,
- unsigned int number_of_keys)
+ bool mget(std::vector<std::string> &keys)
{
+ std::vector<const char *> real_keys;
+ std::vector<size_t> key_len;
+ /*
+ * Construct an array which will contain the length
+ * of each of the strings in the input vector. Also, to
+ * interface with the memcached C API, we need to convert
+ * the vector of std::string's to a vector of char *.
+ */
+ real_keys.reserve(keys.size());
+ key_len.reserve(keys.size());
+
+ std::vector<std::string>::iterator it= keys.begin();
+
+ while (it != keys.end())
+ {
+ real_keys.push_back(const_cast<char *>((*it).c_str()));
+ key_len.push_back((*it).length());
+ ++it;
+ }
+
+ /*
+ * If the std::vector of keys is empty then we cannot
+ * call memcached_mget as we will get undefined behavior.
+ */
+ if (!real_keys.empty())
+ {
+ memcached_return rc= memcached_mget(&memc, &real_keys[0], &key_len[0],
+ static_cast<unsigned int>(real_keys.size()));
+ return (rc == MEMCACHED_SUCCESS);
+ }
- return memcached_mget(&memc, keys, key_length, number_of_keys);
+ return false;
}
- memcached_return set(const char *key, const char *value, size_t value_length)
+ bool set(const std::string &key,
+ const std::string &value,
+ time_t expiration,
+ uint32_t flags)
{
- return memcached_set(&memc, key, strlen(key),
- value, value_length,
- time_t(0), uint32_t(0));
+ memcached_return rc= memcached_set(&memc,
+ key.c_str(), key.length(),
+ value.c_str(), value.length(),
+ expiration, flags);
+ return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
- memcached_return set_by_key(const char *master_key, const char *key,
- const char *value, size_t value_length)
+ bool set_all(std::vector<std::string> &keys,
+ std::vector<std::string> &values,
+ time_t expiration,
+ uint32_t flags)
{
- return memcached_set_by_key(&memc, master_key, strlen(master_key),
- key, strlen(key),
- value, value_length,
- time_t(0),
- uint32_t(0) );
+ if (keys.size() != values.size())
+ {
+ return false;
+ }
+ bool retval= true;
+ std::vector<std::string>::iterator key_it= keys.begin();
+ std::vector<std::string>::iterator val_it= values.begin();
+ while (key_it != keys.end())
+ {
+ retval= set((*key_it), (*val_it), expiration, flags);
+ if (retval == false)
+ {
+ return retval;
+ }
+ ++key_it;
+ ++val_it;
+ }
+ return retval;
}
- memcached_return
- increment(const char *key, unsigned int offset, uint64_t *value)
+
+ bool set_by_key(const std::string &master_key,
+ const std::string &key,
+ const std::string &value,
+ time_t expiration,
+ uint32_t flags)
{
- return memcached_increment(&memc, key, strlen(key),
- offset, value);
+ memcached_return rc= memcached_set_by_key(&memc, master_key.c_str(),
+ master_key.length(),
+ key.c_str(), key.length(),
+ value.c_str(), value.length(),
+ expiration,
+ flags);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return
- decrement(const char *key, unsigned int offset, uint64_t *value)
+
+ bool increment(const std::string &key, unsigned int offset, uint64_t *value)
+ {
+ memcached_return rc= memcached_increment(&memc, key.c_str(), key.length(),
+ offset, value);
+ return (rc == MEMCACHED_SUCCESS);
+ }
+
+ bool decrement(const std::string &key, unsigned int offset, uint64_t *value)
{
- return memcached_decrement(&memc, key, strlen(key),
- offset, value);
+ memcached_return rc= memcached_decrement(&memc, key.c_str(),
+ key.length(),
+ offset, value);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return add(const char *key, const char *value, size_t value_length)
+ bool add(const std::string &key, const std::string &value)
{
- return memcached_add(&memc, key, strlen(key), value, value_length, 0, 0);
+ memcached_return rc= memcached_add(&memc, key.c_str(), key.length(),
+ value.c_str(), value.length(), 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return add_by_key(const char *master_key, const char *key,
- const char *value, size_t value_length)
+
+ bool add_by_key(const std::string &master_key,
+ const std::string &key,
+ const std::string &value)
{
- return memcached_add_by_key(&memc, master_key, strlen(master_key),
- key, strlen(key),
- value, value_length,
- 0, 0);
+ memcached_return rc= memcached_add_by_key(&memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ value.c_str(),
+ value.length(),
+ 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return replace(const char *key, const char *value,
- size_t value_length)
+ bool replace(const std::string &key, const std::string &value)
{
- return memcached_replace(&memc, key, strlen(key),
- value, value_length,
- 0, 0);
+ memcached_return rc= memcached_replace(&memc, key.c_str(), key.length(),
+ value.c_str(), value.length(),
+ 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return replace_by_key(const char *master_key, const char *key,
- const char *value, size_t value_length)
+
+ bool replace_by_key(const std::string &master_key,
+ const std::string &key,
+ const std::string &value)
{
- return memcached_replace_by_key(&memc, master_key, strlen(master_key),
- key, strlen(key),
- value, value_length, 0, 0);
+ memcached_return rc= memcached_replace_by_key(&memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ value.c_str(),
+ value.length(),
+ 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return prepend(const char *key, const char *value,
- size_t value_length)
+ bool prepend(const std::string &key, const std::string &value)
{
- return memcached_prepend(&memc, key, strlen(key),
- value, value_length, 0, 0);
+ memcached_return rc= memcached_prepend(&memc, key.c_str(), key.length(),
+ value.c_str(), value.length(), 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return prepend_by_key(const char *master_key, const char *key,
- const char *value, size_t value_length)
+
+ bool prepend_by_key(const std::string &master_key,
+ const std::string &key,
+ const std::string &value)
{
- return memcached_prepend_by_key(&memc, master_key, strlen(master_key),
- key, strlen(key),
- value, value_length,
- 0,
- 0);
+ memcached_return rc= memcached_prepend_by_key(&memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ value.c_str(),
+ value.length(),
+ 0,
+ 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return append(const char *key, const char *value,
- size_t value_length)
+ bool append(const std::string &key, const std::string &value)
{
- return memcached_append(&memc, key, strlen(key),
- value, value_length, 0, 0);
+ memcached_return rc= memcached_append(&memc,
+ key.c_str(),
+ key.length(),
+ value.c_str(),
+ value.length(),
+ 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return append_by_key(const char *master_key, const char *key,
- const char *value, size_t value_length)
+
+ bool append_by_key(const std::string &master_key,
+ const std::string &key,
+ const std::string &value)
{
- return memcached_append_by_key(&memc,
- master_key, strlen(master_key),
- key, strlen(key),
- value, value_length, 0, 0);
+ memcached_return rc= memcached_append_by_key(&memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ value.c_str(),
+ value.length(),
+ 0, 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return cas(const char *key, const char *value,
- size_t value_length, uint64_t cas)
+
+ bool cas(const std::string &key,
+ const std::string &value,
+ uint64_t cas_arg)
{
- return memcached_cas(&memc, key, strlen(key),
- value, value_length, 0, 0, cas);
+ memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(),
+ value.c_str(), value.length(),
+ 0, 0, cas_arg);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return cas_by_key(const char *master_key, const char *key,
- const char *value, size_t value_length,
- uint64_t cas)
+
+ bool cas_by_key(const std::string &master_key,
+ const std::string &key,
+ const std::string &value,
+ uint64_t cas_arg)
{
- return memcached_cas_by_key(&memc,
- master_key, strlen(master_key),
- key, strlen(key),
- value, value_length,
- 0, 0, cas);
+ memcached_return rc= memcached_cas_by_key(&memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ value.c_str(),
+ value.length(),
+ 0, 0, cas_arg);
+ return (rc == MEMCACHED_SUCCESS);
}
+
// using 'remove' vs. 'delete' since 'delete' is a keyword
- memcached_return remove(const char *key)
+ bool remove(const std::string &key)
{
- return memcached_delete (&memc, key, strlen(key), 0);
+ memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
+ return (rc == MEMCACHED_SUCCESS);
+ }
+ bool delete_by_key(const std::string &master_key,
+ const std::string &key)
+ {
+ memcached_return rc= memcached_delete_by_key(&memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ 0);
+ return (rc == MEMCACHED_SUCCESS);
}
- memcached_return delete_by_key(const char *master_key, const char *key)
+
+ bool flush(time_t expiration)
{
- return memcached_delete_by_key(&memc, master_key, strlen(master_key),
- key, strlen(key), 0);
+ memcached_return rc= memcached_flush(&memc, expiration);
+ return (rc == MEMCACHED_SUCCESS);
}
- ~Memcached()
+
+ bool fetch_execute(memcached_execute_function *callback,
+ void *context,
+ unsigned int num_of_callbacks)
{
- memcached_free(&memc);
+ memcached_return rc= memcached_fetch_execute(&memc,
+ callback,
+ context,
+ num_of_callbacks);
+ return (rc == MEMCACHED_SUCCESS);
}
+
+ const std::string lib_version() const
+ {
+ const char *ver= memcached_lib_version();
+ const std::string version(ver);
+ return version;
+ }
+
+private:
+ memcached_st memc;
+ memcached_result_st result;
};
#include "common.h"
-void libmemcached_free(memcached_st *ptr __attribute__((unused)), void *mem)
+void libmemcached_free(memcached_st *ptr, void *mem)
{
+ (void) ptr;
free(mem);
}
-void *libmemcached_malloc(memcached_st *ptr __attribute__((unused)),
- size_t size)
+void *libmemcached_malloc(memcached_st *ptr, size_t size)
{
+ (void) ptr;
return malloc(size);
}
-void *libmemcached_realloc(memcached_st *ptr __attribute__((unused)),
- void *mem, size_t size)
+void *libmemcached_realloc(memcached_st *ptr, void *mem, size_t size)
{
+ (void) ptr;
return realloc(mem, size);
}
-void *libmemcached_calloc(memcached_st *ptr __attribute__((unused)),
- size_t nelem, size_t size)
+void *libmemcached_calloc(memcached_st *ptr, size_t nelem, size_t size)
{
if (ptr->call_malloc != libmemcached_malloc)
{
unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0)
return MEMCACHED_NO_SERVERS;
- if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+ if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
return MEMCACHED_BAD_KEY_PROVIDED;
server_key= memcached_generate_hash(ptr, key, key_length);
uint64_t memcached_behavior_get(memcached_st *ptr,
memcached_behavior flag)
{
- memcached_flags temp_flag= 0;
+ memcached_flags temp_flag= MEM_NO_BLOCK;
switch (flag)
{
{
size_t key_length= strlen(key);
- if (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)
+ if (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)
{
return MEMCACHED_BAD_KEY_PROVIDED;
}
#ifndef __MEMCACHED_CONSTANTS_H__
#define __MEMCACHED_CONSTANTS_H__
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* Public defines */
#define MEMCACHED_DEFAULT_PORT 11211
#define MEMCACHED_MAX_KEY 251 /* We add one to have it null terminated */
MEMCACHED_CONNECTION_UNIX_SOCKET
} memcached_connection;
-#ifdef __cplusplus
-}
-#endif
-
#endif /* __MEMCACHED_CONSTANTS_H__ */
if ((memcached_do(server, (const char*)request.bytes,
sizeof(request.bytes), 0) != MEMCACHED_SUCCESS) ||
(memcached_io_write(server, key, key_length, flush) == -1))
- memcached_io_reset(server);
+ memcached_io_reset(server);
+ else
+ memcached_server_response_decrement(server);
}
}
#include "common.h"
static memcached_return ascii_dump(memcached_st *ptr, memcached_dump_func *callback, void *context, uint32_t number_of_callbacks)
{
- memcached_return rc;
+ memcached_return rc= 0;
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
size_t send_length;
uint32_t server_key;
*error= memcached_mget_by_key(ptr,
master_key,
master_key_length,
- (char **)&key, &key_length, 1);
+ (const char **)&key, &key_length, 1);
value= memcached_fetch(ptr, NULL, NULL,
value_length, flags, error);
}
memcached_return memcached_mget(memcached_st *ptr,
- char **keys, size_t *key_length,
+ const char **keys, size_t *key_length,
unsigned int number_of_keys)
{
return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
static memcached_return binary_mget_by_key(memcached_st *ptr,
unsigned int master_server_key,
bool is_master_key_set,
- char **keys, size_t *key_length,
+ const char **keys, size_t *key_length,
unsigned int number_of_keys);
memcached_return memcached_mget_by_key(memcached_st *ptr,
const char *master_key,
size_t master_key_length,
- char **keys,
+ const char **keys,
size_t *key_length,
unsigned int number_of_keys)
{
unsigned int x;
memcached_return rc= MEMCACHED_NOTFOUND;
- char *get_command= "get ";
+ const char *get_command= "get ";
uint8_t get_command_length= 4;
unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
bool is_master_key_set= false;
if (master_key && master_key_length)
{
- if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&master_key, &master_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+ if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&master_key, &master_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
return MEMCACHED_BAD_KEY_PROVIDED;
master_server_key= memcached_generate_hash(ptr, master_key, master_key_length);
is_master_key_set= true;
static memcached_return simple_binary_mget(memcached_st *ptr,
unsigned int master_server_key,
bool is_master_key_set,
- char **keys, size_t *key_length,
+ const char **keys, size_t *key_length,
unsigned int number_of_keys)
{
memcached_return rc= MEMCACHED_NOTFOUND;
static memcached_return replication_binary_mget(memcached_st *ptr,
uint32_t* hash, bool* dead_servers,
- char **keys, size_t *key_length,
+ const char **keys, size_t *key_length,
unsigned int number_of_keys)
{
memcached_return rc= MEMCACHED_NOTFOUND;
static memcached_return binary_mget_by_key(memcached_st *ptr,
unsigned int master_server_key,
bool is_master_key_set,
- char **keys, size_t *key_length,
+ const char **keys, size_t *key_length,
unsigned int number_of_keys)
{
memcached_return rc;
#endif
/* Public defines */
+LIBMEMCACHED_API
char *memcached_get(memcached_st *ptr,
const char *key, size_t key_length,
size_t *value_length,
uint32_t *flags,
memcached_return *error);
+LIBMEMCACHED_API
memcached_return memcached_mget(memcached_st *ptr,
- char **keys, size_t *key_length,
+ const char **keys, size_t *key_length,
unsigned int number_of_keys);
+LIBMEMCACHED_API
char *memcached_get_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
uint32_t *flags,
memcached_return *error);
+LIBMEMCACHED_API
memcached_return memcached_mget_by_key(memcached_st *ptr,
const char *master_key, size_t
master_key_length,
- char **keys,
+ const char **keys,
size_t *key_length,
unsigned int number_of_keys);
+LIBMEMCACHED_API
char *memcached_fetch(memcached_st *ptr,
char *key, size_t *key_length,
size_t *value_length, uint32_t *flags,
memcached_return *error);
+LIBMEMCACHED_API
memcached_result_st *memcached_fetch_result(memcached_st *ptr,
memcached_result_st *result,
memcached_return *error);
if (ptr->flags & MEM_HASH_WITH_PREFIX_KEY)
{
- int temp_len= ptr->prefix_key_length + key_length;
- char *temp= (char *)malloc(temp_len);
+ size_t temp_length= ptr->prefix_key_length + key_length;
+ char temp[temp_length];
+
+ if (temp_length > MEMCACHED_MAX_KEY -1)
+ return 0;
+
strncpy(temp, ptr->prefix_key, ptr->prefix_key_length);
strncpy(temp + ptr->prefix_key_length, key, key_length);
- hash= generate_hash(ptr, temp, temp_len);
- free(temp);
+ hash= generate_hash(ptr, temp, temp_length);
}
else
{
* Author: Trond Norbye
*/
-#if !defined(MEMCACHED_INTERNAL_H) && defined(MEMCACHED_INTERNAL)
-#define MEMCACHED_INTERNAL_H
+#ifndef LIBMEMCACHED_MEMCACHED_INTERNAL_H
+#define LIBMEMCACHED_MEMCACHED_INTERNAL_H
+
+#if defined(BUILDING_LIBMEMCACHED)
#ifdef __cplusplus
extern "C" {
#endif
-void libmemcached_free(memcached_st *ptr __attribute__((unused)), void *mem);
-void *libmemcached_malloc(memcached_st *ptr __attribute__((unused)),
- const size_t size);
-void *libmemcached_realloc(memcached_st *ptr __attribute__((unused)),
- void *mem, const size_t size);
-void *libmemcached_calloc(memcached_st *ptr __attribute__((unused)),
- size_t nelem, size_t size);
+LIBMEMCACHED_LOCAL
+void libmemcached_free(memcached_st *ptr, void *mem);
+LIBMEMCACHED_LOCAL
+void *libmemcached_malloc(memcached_st *ptr, const size_t size);
+LIBMEMCACHED_LOCAL
+void *libmemcached_realloc(memcached_st *ptr, void *mem, const size_t size);
+LIBMEMCACHED_LOCAL
+void *libmemcached_calloc(memcached_st *ptr, size_t nelem, size_t size);
+
#ifdef __cplusplus
}
#endif
-#endif /* MEMCACHED_INTERNAL_H */
+#endif /* BUILDING_LIBMEMCACHED */
+#endif /* LIBMEMCACHED_MEMCACHED_INTERNAL_H */
-/* Server IO, Not public! */
-#include "libmemcached/memcached.h"
+/*
+ * Summary: Server IO, Not public!
+ *
+ * Copy: See Copyright for the status of this software.
+ *
+ * Author: Brian Aker
+ */
+
+#ifndef LIBMEMCACHED_MEMCACHED_IO_H
+#define LIBMEMCACHED_MEMCACHED_IO_H
-#ifndef __MEMCACHED_IO_H__
-#define __MEMCACHED_IO_H__
+#if defined(BUILDING_LIBMEMCACHED)
+
+#include "libmemcached/memcached.h"
#define MAX_UDP_DATAGRAM_LENGTH 1400
#define UDP_DATAGRAM_HEADER_LENGTH 8
memcached_server_st *memcached_io_get_readable_server(memcached_st *memc);
-#endif /* __MEMCACHED_IO_H__ */
+#endif /* BUILDING_LIBMEMCACHED */
+#endif /* LIBMEMCACHED_MEMCACHED_IO_H */
#include "common.h"
-memcached_return memcached_key_test(char **keys, size_t *key_length,
+memcached_return memcached_key_test(const char **keys, size_t *key_length,
unsigned int number_of_keys)
{
uint32_t x;
Frankly its too damn useful not to be here though.
*/
-#include "libmemcached/memcached.h"
#include "common.h"
memcached_server_st *memcached_servers_parse(const char *server_strings)
struct memcached_pool_st;
typedef struct memcached_pool_st memcached_pool_st;
+
+LIBMEMCACHED_API
memcached_pool_st *memcached_pool_create(memcached_st* mmc, uint32_t initial,
uint32_t max);
+LIBMEMCACHED_API
memcached_st* memcached_pool_destroy(memcached_pool_st* pool);
+LIBMEMCACHED_API
memcached_st* memcached_pool_pop(memcached_pool_st* pool,
bool block,
memcached_return* rc);
+LIBMEMCACHED_API
memcached_return memcached_pool_push(memcached_pool_st* pool,
memcached_st* mmc);
memcached_server_response_increment(ptr);
return MEMCACHED_STAT;
}
- else if (buffer[1] == 'E')
+ else if (buffer[1] == 'E') /* SERVER_ERROR */
{
- /* SERVER_ERROR */
+ char *rel_ptr;
char *startptr= buffer + 13, *endptr= startptr;
+
while (*endptr != '\r' && *endptr != '\n') endptr++;
- if (ptr->cached_server_error) ptr->root->call_free(ptr->root, ptr->cached_server_error);
- ptr->cached_server_error= ptr->root->call_malloc(ptr->root, endptr - startptr + 1);
+
+ /*
+ Yes, we could make this "efficent" but to do that we would need
+ to maintain more state for the size of the buffer. Why waste
+ memory in the struct, which is important, for something that
+ rarely should happen?
+ */
+ rel_ptr= (char *)ptr->root->call_realloc(ptr->root, ptr->cached_server_error, endptr - startptr + 1);
+
+ if (rel_ptr == NULL)
+ {
+ /* If we happened to have some memory, we just null it since we don't know the size */
+ if (ptr->cached_server_error)
+ ptr->cached_server_error[0]= 0;
+ return MEMCACHED_SERVER_ERROR;
+ }
+ ptr->cached_server_error= rel_ptr;
+
memcpy(ptr->cached_server_error, startptr, endptr - startptr);
ptr->cached_server_error[endptr - startptr]= 0;
return MEMCACHED_SERVER_ERROR;
/*
NOTE turn into macro
*/
-memcached_return memcached_result_set_value(memcached_result_st *ptr, char *value, size_t length)
+memcached_return memcached_result_set_value(memcached_result_st *ptr, const char *value, size_t length)
{
return memcached_string_append(&ptr->value, value, length);
}
};
/* Result Struct */
+LIBMEMCACHED_API
void memcached_result_free(memcached_result_st *result);
+LIBMEMCACHED_API
void memcached_result_reset(memcached_result_st *ptr);
+LIBMEMCACHED_API
memcached_result_st *memcached_result_create(memcached_st *ptr,
memcached_result_st *result);
#define memcached_result_key_value(A) (A)->key
#define memcached_result_value(A) memcached_string_value((A)->value)
#define memcached_result_length(A) memcached_string_length((A)->value)
#else
+LIBMEMCACHED_API
char *memcached_result_value(memcached_result_st *ptr);
+LIBMEMCACHED_API
size_t memcached_result_length(memcached_result_st *ptr);
#endif
#define memcached_result_flags(A) (A)->flags
#define memcached_result_cas(A) (A)->cas
-memcached_return memcached_result_set_value(memcached_result_st *ptr, char *value, size_t length);
+LIBMEMCACHED_API
+memcached_return memcached_result_set_value(memcached_result_st *ptr, const char *value, size_t length);
#define memcached_result_set_flags(A,B) (A)->flags=(B)
#define memcached_result_set_expiration(A,B) (A)->expiration=(B)
memcached_quit_server(ptr, 0);
if (ptr->cached_server_error)
- {
free(ptr->cached_server_error);
- ptr->cached_server_error= NULL;
- }
if (ptr->address_info)
- {
freeaddrinfo(ptr->address_info);
- ptr->address_info= NULL;
- }
if (ptr->is_allocated)
ptr->root->call_free(ptr->root, ptr);
*/
memcached_server_st *memcached_server_clone(memcached_server_st *clone, memcached_server_st *ptr)
{
- memcached_server_st *rv = NULL;
+ memcached_server_st *rv= NULL;
/* We just do a normal create if ptr is missing */
if (ptr == NULL)
return NULL;
}
- if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+ if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
{
*error= MEMCACHED_BAD_KEY_PROVIDED;
return NULL;
return memcached_server_clone(NULL, &ptr->hosts[server_key]);
}
+
+const char *memcached_server_error(memcached_server_st *ptr)
+{
+ if (ptr)
+ return ptr->cached_server_error;
+ else
+ return NULL;
+}
+
+void memcached_server_error_reset(memcached_server_st *ptr)
+{
+ ptr->cached_server_error[0]= 0;
+}
unsigned int port;
int cached_errno;
int fd;
- char *cached_server_error;
uint32_t io_bytes_sent; /* # bytes sent since last read */
uint32_t server_failure_counter;
uint32_t weight;
uint8_t minor_version;
memcached_connection type;
char *read_ptr;
+ char *cached_server_error;
size_t read_buffer_length;
size_t read_data_length;
size_t write_buffer_offset;
#define memcached_server_list(A) (A)->hosts
#define memcached_server_response_count(A) (A)->cursor_active
+LIBMEMCACHED_API
memcached_return memcached_server_cursor(memcached_st *ptr,
memcached_server_function *callback,
void *context,
unsigned int number_of_callbacks);
+LIBMEMCACHED_API
memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key,
size_t key_length, memcached_return *error);
+LIBMEMCACHED_API
+const char *memcached_server_error(memcached_server_st *ptr);
+
+LIBMEMCACHED_API
+void memcached_server_error_reset(memcached_server_st *ptr);
+
/* These should not currently be used by end users */
+/* TODO: Is the above comment valid? If so, how can we unit test these if they
+ * aren't exported. If not, we should remove the comment */
+LIBMEMCACHED_API
memcached_server_st *memcached_server_create(memcached_st *memc, memcached_server_st *ptr);
+LIBMEMCACHED_API
memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host,
const char *hostname, unsigned int port,
uint32_t weight, memcached_connection type);
+LIBMEMCACHED_API
void memcached_server_free(memcached_server_st *ptr);
+LIBMEMCACHED_API
memcached_server_st *memcached_server_clone(memcached_server_st *clone, memcached_server_st *ptr);
-memcached_analysis_st *memcached_analyze(memcached_st *memc, memcached_stat_st *stat,
+LIBMEMCACHED_API
+memcached_analysis_st *memcached_analyze(memcached_st *memc, memcached_stat_st *memc_stat,
memcached_return *error);
+LIBMEMCACHED_API
+memcached_return memcached_server_remove(memcached_server_st *st_ptr);
#ifdef __cplusplus
}
#include "common.h"
-static char *memcached_stat_keys[] = {
+static const char *memcached_stat_keys[] = {
"pid",
"uptime",
"time",
} memcached_storage_action;
/* Inline this */
-static char *storage_op_string(memcached_storage_action verb)
+static const char *storage_op_string(memcached_storage_action verb)
{
switch (verb)
{
unlikely (ptr->number_of_hosts == 0)
return MEMCACHED_NO_SERVERS;
- if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+ if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
return MEMCACHED_BAD_KEY_PROVIDED;
if (ptr->flags & MEM_BINARY_PROTOCOL)
send_length, 0) != MEMCACHED_SUCCESS) ||
(memcached_io_write(srv, key, key_length, 0) == -1) ||
(memcached_io_write(srv, value, value_length, flush) == -1))
- memcached_io_reset(server);
+ memcached_io_reset(srv);
+ else
+ memcached_server_response_decrement(srv);
}
}
#ifndef __MEMCACHED_STORAGE_H__
#define __MEMCACHED_STORAGE_H__
+#include "libmemcached/memcached_types.h"
+
#ifdef __cplusplus
extern "C" {
#endif
/* All of the functions for adding data to the server */
+LIBMEMCACHED_API
memcached_return memcached_set(memcached_st *ptr, const char *key, size_t key_length,
const char *value, size_t value_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_add(memcached_st *ptr, const char *key, size_t key_length,
const char *value, size_t value_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_replace(memcached_st *ptr, const char *key, size_t key_length,
const char *value, size_t value_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_append(memcached_st *ptr,
const char *key, size_t key_length,
const char *value, size_t value_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_prepend(memcached_st *ptr,
const char *key, size_t key_length,
const char *value, size_t value_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_cas(memcached_st *ptr,
const char *key, size_t key_length,
const char *value, size_t value_length,
uint32_t flags,
uint64_t cas);
+LIBMEMCACHED_API
memcached_return memcached_set_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_add_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_replace_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_prepend_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_append_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
time_t expiration,
uint32_t flags);
+LIBMEMCACHED_API
memcached_return memcached_cas_by_key(memcached_st *ptr,
const char *master_key, size_t master_key_length,
const char *key, size_t key_length,
#include "common.h"
-char *memcached_strerror(memcached_st *ptr __attribute__((unused)), memcached_return rc)
+const char *memcached_strerror(memcached_st *ptr __attribute__((unused)), memcached_return rc)
{
switch (rc)
{
}
memcached_return memcached_string_append(memcached_string_st *string,
- char *value, size_t length)
+ const char *value, size_t length)
{
memcached_return rc;
#define memcached_string_size(A) (A)->current_size
#define memcached_string_value(A) (A)->string
+LIBMEMCACHED_API
memcached_string_st *memcached_string_create(memcached_st *ptr,
memcached_string_st *string,
size_t initial_size);
+LIBMEMCACHED_API
memcached_return memcached_string_check(memcached_string_st *string, size_t need);
+LIBMEMCACHED_API
char *memcached_string_c_copy(memcached_string_st *string);
+LIBMEMCACHED_API
memcached_return memcached_string_append_character(memcached_string_st *string,
char character);
+LIBMEMCACHED_API
memcached_return memcached_string_append(memcached_string_st *string,
- char *value, size_t length);
+ const char *value, size_t length);
+LIBMEMCACHED_API
memcached_return memcached_string_reset(memcached_string_st *string);
+LIBMEMCACHED_API
void memcached_string_free(memcached_string_st *string);
#ifdef __cplusplus
#ifndef MEMCACHED_UTIL_H
#define MEMCACHED_UTIL_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#include <libmemcached/memcached_pool.h>
-#ifdef __cplusplus
-}
-#endif
-
#endif /* MEMCACHED_UTIL_H */
memcached_return rc;
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
char *response_ptr;
- char *command= "version\r\n";
+ const char *command= "version\r\n";
send_length= strlen(command);
* Author: Brian Aker
*/
-#ifndef __MEMCACHED_WATCHPOINT_H__
-#define __MEMCACHED_WATCHPOINT_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef LIBMEMCACHED_MEMCACHED_WATCHPOINT_H
+#define LIBMEMCACHED_MEMCACHED_WATCHPOINT_H
/* Some personal debugging functions */
-#if defined(MEMCACHED_INTERNAL) && defined(DEBUG)
+#if defined(DEBUG)
+
#include <assert.h>
#define WATCHPOINT fprintf(stderr, "\nWATCHPOINT %s:%d (%s)\n", __FILE__, __LINE__,__func__);fflush(stdout);
#define WATCHPOINT_ASSERT_PRINT(A,B,C)
#define WATCHPOINT_ASSERT(A)
-#endif /* MEMCACHED_INTERNAL && DEBUG */
-
-#ifdef __cplusplus
-}
-#endif
+#endif /* DEBUG */
-#endif /* __MEMCACHED_WATCHPOINT_H__ */
+#endif /* LIBMEMCACHED_MEMCACHED_WATCHPOINT_H */
--- /dev/null
+/*
+ * Summary: interface for memcached server
+ * Description: visibitliy macros for libmemcached
+ *
+ * Use and distribution licensed under the BSD license. See
+ * the COPYING file in this directory for full text.
+ *
+ * Author: Monty Taylor
+ */
+
+/**
+ * @file
+ * @brief Visibility control macros
+ */
+
+#ifndef __LIBMEMCACHED_VISIBILITY_H
+#define __LIBMEMCACHED_VISIBILITY_H
+
+/**
+ *
+ * LIBMEMCACHED_API is used for the public API symbols. It either DLL imports or
+ * DLL exports (or does nothing for static build).
+ *
+ * LIBMEMCACHED_LOCAL is used for non-api symbols.
+ */
+
+#if defined(BUILDING_LIBMEMCACHED)
+# if defined(HAVE_VISIBILITY) && HAVE_VISIBILITY
+# define LIBMEMCACHED_API __attribute__ ((visibility("default")))
+# define LIBMEMCACHED_LOCAL __attribute__ ((visibility("hidden")))
+# elif defined (__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+# define LIBMEMCACHED_API __global
+# define LIBMEMCACHED_LOCAL __hidden
+# elif defined(_MSC_VER)
+# define LIBMEMCACHED_API extern __declspec(dllexport)
+# define LIBMEMCACHED_LOCAL
+# else
+# define LIBMEMCACHED_API
+# define LIBMEMCACHED_LOCAL
+# endif /* defined(HAVE_VISIBILITY) */
+#else /* defined(BUILDING_LIBMEMCACHED) */
+# if defined(_MSC_VER)
+# define LIBMEMCACHED_API extern __declspec(dllimport)
+# define LIBMEMCACHED_LOCAL
+# else
+# define LIBMEMCACHED_API
+# define LIBMEMCACHED_LOCAL
+# endif /* defined(_MSC_VER) */
+#endif /* defined(BUILDING_LIBMEMCACHED) */
+
+#endif /* __LIBMEMCACHED_VISIBILITY_H */
#include "libmemcached/common.h"
#include "libmemcached/memcached_pool.h"
+
+#include <errno.h>
#include <pthread.h>
struct memcached_pool_st
+++ /dev/null
-dnl ---------------------------------------------------------------------------
-dnl Macro: ENABLE_64BIT
-dnl ---------------------------------------------------------------------------
-AC_DEFUN([ENABLE_64BIT],[
-
- AC_CHECK_PROGS(ISAINFO, [isainfo], [no])
- AS_IF([test "x$ISAINFO" != "xno"],
- [isainfo_b=`${ISAINFO} -b`],
- [isainfo_b="x"])
-
- AS_IF([test "$isainfo_b" != "x"],
- [AC_ARG_ENABLE([64bit],
- [AS_HELP_STRING([--disable-64bit],
- [Build 64 bit binary @<:@default=on@:>@])],
- [ac_enable_64bit="$enableval"],
- [ac_enable_64bit="yes"])])
-
- AS_IF([test "x$ac_enable_64bit" = "xyes"],[
- if test "x$libdir" = "x\${exec_prefix}/lib" ; then
- # The user hasn't overridden the default libdir, so we'll
- # the dir suffix to match solaris 32/64-bit policy
- isainfo_k=`${ISAINFO} -k`
- libdir="${libdir}/${isainfo_k}"
- fi
- CFLAGS="-m64 $CFLAGS"
- CXXFLAGS="-m64 $CXXFLAGS"
- if test "$target_cpu" = "sparc" -a "x$SUNCC" = "xyes"
- then
- CFLAGS="-xmemalign=8s $CFLAGS"
- CXXFLAGS="-xmemalign=8s $CXXFLAGS"
- fi
- ])
-])
-dnl ---------------------------------------------------------------------------
-dnl End Macro: ENABLE_64BIT
-dnl ---------------------------------------------------------------------------
--- /dev/null
+# ===========================================================================
+# http://autoconf-archive.cryp.to/ac_cxx_compile_stdcxx_0x.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+# AC_CXX_COMPILE_STDCXX_0X
+#
+# DESCRIPTION
+#
+# Check for baseline language coverage in the compiler for the C++0x
+# standard.
+#
+# LICENSE
+#
+# Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.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.
+
+AC_DEFUN([AC_CXX_COMPILE_STDCXX_0X], [
+ AC_CACHE_CHECK(if g++ supports C++0x features without additional flags,
+ ac_cv_cxx_compile_cxx0x_native,
+ [AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ AC_TRY_COMPILE([
+ template <typename T>
+ struct check
+ {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };
+
+ typedef check<check<bool>> right_angle_brackets;
+
+ int a;
+ decltype(a) b;
+
+ typedef check<int> check_type;
+ check_type c;
+ check_type&& cr = c;],,
+ ac_cv_cxx_compile_cxx0x_native=yes, ac_cv_cxx_compile_cxx0x_native=no)
+ AC_LANG_RESTORE
+ ])
+
+ AC_CACHE_CHECK(if g++ supports C++0x features with -std=c++0x,
+ ac_cv_cxx_compile_cxx0x_cxx,
+ [AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=c++0x"
+ AC_TRY_COMPILE([
+ template <typename T>
+ struct check
+ {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };
+
+ typedef check<check<bool>> right_angle_brackets;
+
+ int a;
+ decltype(a) b;
+
+ typedef check<int> check_type;
+ check_type c;
+ check_type&& cr = c;],,
+ ac_cv_cxx_compile_cxx0x_cxx=yes, ac_cv_cxx_compile_cxx0x_cxx=no)
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+ ])
+
+ AC_CACHE_CHECK(if g++ supports C++0x features with -std=gnu++0x,
+ ac_cv_cxx_compile_cxx0x_gxx,
+ [AC_LANG_SAVE
+ AC_LANG_CPLUSPLUS
+ ac_save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="$CXXFLAGS -std=gnu++0x"
+ AC_TRY_COMPILE([
+ template <typename T>
+ struct check
+ {
+ static_assert(sizeof(int) <= sizeof(T), "not big enough");
+ };
+
+ typedef check<check<bool>> right_angle_brackets;
+
+ int a;
+ decltype(a) b;
+
+ typedef check<int> check_type;
+ check_type c;
+ check_type&& cr = c;],,
+ ac_cv_cxx_compile_cxx0x_gxx=yes, ac_cv_cxx_compile_cxx0x_gxx=no)
+ CXXFLAGS="$ac_save_CXXFLAGS"
+ AC_LANG_RESTORE
+ ])
+
+ if test "$ac_cv_cxx_compile_cxx0x_native" = yes ||
+ test "$ac_cv_cxx_compile_cxx0x_cxx" = yes ||
+ test "$ac_cv_cxx_compile_cxx0x_gxx" = yes; then
+ AC_DEFINE(HAVE_STDCXX_0X,,[Define if g++ supports C++0x features. ])
+ fi
+])
--- /dev/null
+dnl Copyright © 2008 Benjamin Kosnik <bkoz@redhat.com>
+
+dnl 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.
+
+
+AC_DEFUN([AC_CXX_HEADER_STDCXX_98], [
+ AC_CACHE_CHECK(for ISO C++ 98 include files,
+ ac_cv_cxx_stdcxx_98,
+ [AC_LANG_PUSH(C++)
+ AC_TRY_COMPILE([
+ #include <cassert>
+ #include <cctype>
+ #include <cerrno>
+ #include <cfloat>
+ #include <ciso646>
+ #include <climits>
+ #include <clocale>
+ #include <cmath>
+ #include <csetjmp>
+ #include <csignal>
+ #include <cstdarg>
+ #include <cstddef>
+ #include <cstdio>
+ #include <cstdlib>
+ #include <cstring>
+ #include <ctime>
+
+ #include <algorithm>
+ #include <bitset>
+ #include <complex>
+ #include <deque>
+ #include <exception>
+ #include <fstream>
+ #include <functional>
+ #include <iomanip>
+ #include <ios>
+ #include <iosfwd>
+ #include <iostream>
+ #include <istream>
+ #include <iterator>
+ #include <limits>
+ #include <list>
+ #include <locale>
+ #include <map>
+ #include <memory>
+ #include <new>
+ #include <numeric>
+ #include <ostream>
+ #include <queue>
+ #include <set>
+ #include <sstream>
+ #include <stack>
+ #include <stdexcept>
+ #include <streambuf>
+ #include <string>
+ #include <typeinfo>
+ #include <utility>
+ #include <valarray>
+ #include <vector>
+ ],,
+ ac_cv_cxx_stdcxx_98=yes, ac_cv_cxx_stdcxx_98=no)
+ AC_LANG_POP()
+ ])
+ if test "$ac_cv_cxx_stdcxx_98" = yes; then
+ AC_DEFINE(STDCXX_98_HEADERS,,[Define if ISO C++ 1998 header files are present. ])
+ fi
+])
+++ /dev/null
-AC_DEFUN([FORCE_MAC_GCC42],
- [AS_IF([test "$GCC" = "yes"],[
- dnl If you're on a Mac, and you didn't ask for a specific compiler
- dnl You're gonna get 4.2.
- AS_IF([test "$host_vendor" = "apple" -a "x${ac_cv_env_CC_set}" = "x"],[
- AS_IF([test -f /usr/bin/gcc-4.2],
- [
- CPP="/usr/bin/gcc-4.2 -E"
- CC=/usr/bin/gcc-4.2
- CXX=/usr/bin/g++-4.2
- ])
- ])
- ])
-])
-
-AC_DEFUN([CHECK_GCC_VERSION],[
- AC_REQUIRE([FORCE_MAC_GCC42])
- AC_CACHE_CHECK([if GCC is recent enough], [ac_cv_gcc_recent],
- [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-#if !defined(__GNUC__) || (__GNUC__ < 4) || ((__GNUC__ >= 4) && (__GNUC_MINOR__ < 1))
-# error GCC is Too Old!
-#endif
- ]])],
- [ac_cv_gcc_recent=yes],
- [ac_cv_gcc_recent=no])])
- AS_IF([test "$ac_cv_gcc_recent" = "no" -a "$host_vendor" = "apple"],
- AC_MSG_ERROR([Your version of GCC is too old. At least version 4.2 is required on OSX. You may need to install a version of XCode >= 3.1.2]))
- AS_IF([test "$drizzle_cv_gcc_recent" = "no"],
- AC_MSG_ERROR([Your version of GCC is too old. At least version 4.1 is required]))
-])
+++ /dev/null
-dnl ---------------------------------------------------------------------------
-dnl Macro: ENABLE_DTRACE
-dnl ---------------------------------------------------------------------------
-AC_DEFUN([ENABLE_DTRACE],[
- AC_ARG_ENABLE([dtrace],
- [AS_HELP_STRING([--enable-dtrace],
- [Build with support for the DTRACE. @<:@default=off@:>@])],
- [ac_cv_enable_dtrace="yes"],
- [ac_cv_enable_dtrace="no"])
-
- if test "$ac_cv_enable_dtrace" = "yes"
- then
- AC_PATH_PROG([DTRACE], [dtrace], "no", [/usr/sbin:$PATH])
- if test "x$DTRACE" != "xno"; then
- AC_DEFINE([HAVE_DTRACE], [1], [Enables DTRACE Support])
- DTRACE_HEADER=dtrace_probes.h
-
- # DTrace on MacOSX does not use -G option
- $DTRACE -G -o conftest.$$ -s libmemcached/libmemcached_probes.d 2>/dev/zero
- if test $? -eq 0
- then
- DTRACE_OBJ=libmemcached_probes.lo
- rm conftest.$$
- fi
-
- ac_cv_enable_dtrace="yes"
- AC_SUBST(HAVE_DTRACE)
- else
- AC_MSG_ERROR([Need dtrace binary and OS support.])
- fi
- fi
-
- AC_SUBST(DTRACEFLAGS)
- AC_SUBST(DTRACE_HEADER)
- AC_SUBST(DTRACE_OBJ)
- AM_CONDITIONAL([HAVE_DTRACE], [ test "$ac_cv_enable_dtrace" = "yes" ])
-])
-dnl ---------------------------------------------------------------------------
-dnl End Macro: ENABLE_DTRACE
-dnl ---------------------------------------------------------------------------
# AC_DEFINE. The goal here is to define all known feature-enabling
# macros, then, if reports of conflicts are made, disable macros that
# cause problems on some platforms (such as __EXTENSIONS__).
-AC_DEFUN([ACX_USE_SYSTEM_EXTENSIONS],
+AC_DEFUN([AC_USE_SYSTEM_EXTENSIONS],
[AC_BEFORE([$0], [AC_COMPILE_IFELSE])dnl
AC_BEFORE([$0], [AC_RUN_IFELSE])dnl
# just ignore the user if --without-memcached is passed.. it is
# only used by make test
AS_IF([test "x$withval" = "xno"],
- [ac_cv_with_memcached=memcached])
-
- AC_PATH_PROG([MEMC_BINARY], [$ac_cv_with_memcached], "no")
-
- AS_IF([test "x$MEMC_BINARY" = "xno"],
- AC_MSG_ERROR(["could not find memcached binary"]))
+ [
+ ac_cv_with_memcached=memcached
+ MEMC_BINARY=memcached
+ ],
+ [
+ AS_IF([test -f "$withval"],
+ [
+ ac_cv_with_memcached=$withval
+ MEMC_BINARY=$withval
+ ],
+ [
+ AC_PATH_PROG([MEMC_BINARY], [$ac_cv_with_memcached], "no")
+ AS_IF([test "x$MEMC_BINARY" = "xno"],
+ AC_MSG_ERROR(["could not find memcached binary"]))
+ ])
+ ])
AC_DEFINE_UNQUOTED([MEMCACHED_BINARY], "$MEMC_BINARY",
[Name of the memcached binary used in make test])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl ---------------------------------------------------------------------------
+dnl Macro: PANDORA_64BIT
+dnl ---------------------------------------------------------------------------
+AC_DEFUN([PANDORA_64BIT],[
+
+ AC_ARG_ENABLE([64bit],[
+ AS_HELP_STRING([--disable-64bit],
+ [Build 64 bit binary @<:@default=on@:>@])],
+ [ac_enable_64bit="$enableval"],
+ [ac_enable_64bit="yes"])
+
+ AC_CHECK_PROGS(ISAINFO, [isainfo], [no])
+ AS_IF([test "x$ISAINFO" != "xno"],
+ [isainfo_b=`${ISAINFO} -b`],
+ [isainfo_b="x"])
+
+ AS_IF([test "$isainfo_b" != "x"],[
+
+ isainfo_k=`${ISAINFO} -k`
+ DTRACEFLAGS="${DTRACEFLAGS} -${isainfo_k}"
+
+ AS_IF([test "x${ac_cv_env_CPPFLAGS_set}" = "x"],[
+ CPPFLAGS="-I/usr/local ${CPPFLAGS}"
+ ])
+
+ AS_IF([test "x${ac_cv_env_LDFLAGS_set}" = "x"],[
+ LDFLAGS="-L/usr/local/lib/${isainfo_k} ${LDFLAGS}"
+ ])
+
+ AS_IF([test "x$ac_enable_64bit" = "xyes"],[
+ AS_IF([test "x$libdir" = "x\${exec_prefix}/lib"],[
+ dnl The user hasn't overridden the default libdir, so we'll
+ dnl the dir suffix to match solaris 32/64-bit policy
+ libdir="${libdir}/${isainfo_k}"
+ ])
+
+ CPPFLAGS="-m64 ${CPPFLAGS}"
+ LDFLAGS="-m64 ${LDFLAGS}"
+ AS_IF([test "$target_cpu" = "sparc" -a "x$SUNCC" = "xyes"],[
+ AM_CFLAGS="-xmemalign=8s ${AM_CFLAGS}"
+ AM_CXXFLAGS="-xmemalign=8s ${AM_CXXFLAGS}"
+ ])
+ ])
+ ])
+])
+dnl ---------------------------------------------------------------------------
+dnl End Macro: PANDORA_64BIT
+dnl ---------------------------------------------------------------------------
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl Which version of the canonical setup we're using
+AC_DEFUN([PANDORA_CANONICAL_VERSION],[0.13])
+
+AC_DEFUN([PANDORA_FORCE_DEPEND_TRACKING],[
+ dnl Force dependency tracking on for Sun Studio builds
+ AS_IF([test "x${enable_dependency_tracking}" = "x"],[
+ enable_dependency_tracking=yes
+ ])
+])
+
+dnl The standard setup for how we build Pandora projects
+AC_DEFUN([PANDORA_CANONICAL_TARGET],[
+ AC_REQUIRE([PANDORA_FORCE_DEPEND_TRACKING])
+ ifdef([m4_define],,[define([m4_define], defn([define]))])
+ ifdef([m4_undefine],,[define([m4_undefine], defn([undefine]))])
+ m4_define([PCT_ALL_ARGS],[$*])
+ m4_define([PCT_USE_GNULIB],[no])
+ m4_define([PCT_REQUIRE_CXX],[no])
+ m4_define([PCT_IGNORE_SHARED_PTR],[no])
+ m4_define([PCT_FORCE_GCC42],[no])
+ m4_foreach([pct_arg],[$*],[
+ m4_case(pct_arg,
+ [use-gnulib], [
+ m4_undefine([PCT_USE_GNULIB])
+ m4_define([PCT_USE_GNULIB],[yes])
+ ],
+ [require-cxx], [
+ m4_undefine([PCT_REQUIRE_CXX])
+ m4_define([PCT_REQUIRE_CXX],[yes])
+ ],
+ [ignore-shared-ptr], [
+ m4_undefine([PCT_IGNORE_SHARED_PTR])
+ m4_define([PCT_IGNORE_SHARED_PTR],[yes])
+ ],
+ [force-gcc42], [
+ m4_undefine([PCT_FORCE_GCC42])
+ m4_define([PCT_FORCE_GCC42],[yes])
+ ])
+ ])
+
+ # We need to prevent canonical target
+ # from injecting -O2 into CFLAGS - but we won't modify anything if we have
+ # set CFLAGS on the command line, since that should take ultimate precedence
+ AS_IF([test "x${ac_cv_env_CFLAGS_set}" = "x"],
+ [CFLAGS=""])
+ AS_IF([test "x${ac_cv_env_CXXFLAGS_set}" = "x"],
+ [CXXFLAGS=""])
+
+ AC_CANONICAL_TARGET
+
+ AM_INIT_AUTOMAKE(-Wall -Werror nostdinc subdir-objects)
+
+ m4_if(PCT_USE_GNULIB,yes,[ gl_EARLY ])
+
+ AC_REQUIRE([AC_PROG_CC])
+ AC_REQUIRE([PANDORA_MAC_GCC42])
+
+ dnl Once we can use a modern autoconf, we can use this
+ dnl AC_PROG_CC_C99
+ AC_PROG_CXX
+ AC_PROG_CPP
+ AM_PROG_CC_C_O
+
+ gl_USE_SYSTEM_EXTENSIONS
+ m4_if(PCT_FORCE_GCC42, [yes], [
+ AS_IF([test "$GCC" = "yes"], PANDORA_ENSURE_GCC_VERSION)
+ ])
+
+
+ PANDORA_LIBTOOL
+
+ dnl autoconf doesn't automatically provide a fail-if-no-C++ macro
+ dnl so we check c++98 features and fail if we don't have them, mainly
+ dnl for that reason
+ PANDORA_CHECK_CXX_STANDARD
+ m4_if(PCT_REQUIRE_CXX, [yes], [
+ AS_IF([test "$ac_cv_cxx_stdcxx_98" = "no"],[
+ AC_MSG_ERROR([No working C++ Compiler has been found. ${PACKAGE} requires a C++ compiler that can handle C++98])
+ ])
+ ])
+
+ PANDORA_SHARED_PTR
+ m4_if(PCT_IGNORE_SHARED_PTR, [no], [
+ AS_IF([test "$ac_cv_shared_ptr_namespace" = "missing"],[
+ AC_MSG_WARN([a usable shared_ptr implementation was not found. Let someone know what your platform is.])
+ ])
+ ])
+
+ m4_if(PCT_USE_GNULIB, [yes], [gl_INIT])
+
+ AC_C_BIGENDIAN
+ AC_C_CONST
+ AC_C_INLINE
+ AC_C_VOLATILE
+
+ AC_HEADER_TIME
+ AC_TYPE_SIZE_T
+ AC_FUNC_MALLOC
+ AC_FUNC_REALLOC
+
+
+ AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])
+
+ AC_SYS_LARGEFILE
+
+
+ PANDORA_CHECK_C_VERSION
+ PANDORA_CHECK_CXX_VERSION
+
+ PANDORA_OPTIMIZE
+ PANDORA_64BIT
+
+ dnl We need to inject error into the cflags to test if visibility works or not
+ save_CFLAGS="${CFLAGS}"
+ CFLAGS="${CFLAGS} -Werror"
+ gl_VISIBILITY
+ CFLAGS="${save_CFLAGS}"
+
+ PANDORA_HEADER_ASSERT
+
+ PANDORA_WARNINGS(PCT_ALL_ARGS)
+
+ PANDORA_ENABLE_DTRACE
+
+ AC_CHECK_PROGS([DOXYGEN], [doxygen])
+ AC_CHECK_PROGS([PERL], [perl])
+
+ AS_IF([test "x${gl_LIBOBJS}" != "x"],[
+ AS_IF([test "$GCC" = "yes"],[
+ AM_CPPFLAGS="-isystem \$(top_srcdir)/gnulib -isystem \$(top_builddir)/gnulib ${AM_CPPFLAGS}"
+ ],[
+ AM_CPPFLAGS="-I\$(top_srcdir)/gnulib -I\$(top_builddir)/gnulib ${AM_CPPFLAGS}"
+ ])
+ ])
+
+ AM_CPPFLAGS="-I\${top_srcdir} -I\${top_builddir} ${AM_CPPFLAGS}"
+ AM_CFLAGS="${AM_CFLAGS} ${CC_WARNINGS} ${CC_PROFILING} ${CC_COVERAGE}"
+ AM_CXXFLAGS="${AM_CXXFLAGS} ${CXX_WARNINGS} ${CC_PROFILING} ${CC_COVERAGE}"
+
+ AC_SUBST([AM_CFLAGS])
+ AC_SUBST([AM_CXXFLAGS])
+ AC_SUBST([AM_CPPFLAGS])
+
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+
+AC_DEFUN([PANDORA_CHECK_C_VERSION],[
+
+ dnl Print version of C compiler
+ AC_MSG_CHECKING("C Compiler version--$GCC")
+ AS_IF([test "$GCC" = "yes"],[
+ CC_VERSION=`$CC --version | sed 1q`
+ ],[AS_IF([test "$SUNCC" = "yes"],[
+ CC_VERSION=`$CC -V 2>&1 | sed 1q`
+ ],[
+ CC_VERSION=""
+ ])
+ ])
+ AC_MSG_RESULT("$CC_VERSION")
+ AC_SUBST(CC_VERSION)
+])
+
+
+AC_DEFUN([PANDORA_CHECK_CXX_VERSION], [
+ dnl Print version of CXX compiler
+ AC_MSG_CHECKING("C++ Compiler version")
+ AS_IF([test "$GCC" = "yes"],[
+ CXX_VERSION=`$CXX --version | sed 1q`
+ ],[AS_IF([test "$SUNCC" = "yes"],[
+ CXX_VERSION=`$CXX -V 2>&1 | sed 1q`
+ ],[
+ CXX_VERSION=""
+ ])
+ ])
+ AC_MSG_RESULT("$CXX_VERSION")
+ AC_SUBST(CXX_VERSION)
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([PANDORA_CHECK_CXX_STANDARD],[
+ AC_REQUIRE([AC_CXX_COMPILE_STDCXX_0X])
+ AS_IF([test "$GCC" = "yes"],
+ [AS_IF([test "$ac_cv_cxx_compile_cxx0x_native" = "yes"],[],
+ [AS_IF([test "$ac_cv_cxx_compile_cxx0x_gxx" = "yes"],
+ [CXXFLAGS="-std=gnu++0x ${CXXFLAGS}"],
+ [CXXFLAGS="-std=gnu++98"])
+ ])
+ ])
+ AC_CXX_HEADER_STDCXX_98
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl ---------------------------------------------------------------------------
+dnl Macro: PANDORA_ENABLE_DTRACE
+dnl ---------------------------------------------------------------------------
+AC_DEFUN([PANDORA_ENABLE_DTRACE],[
+ AC_ARG_ENABLE([dtrace],
+ [AS_HELP_STRING([--enable-dtrace],
+ [Build with support for the DTRACE. @<:@default=off@:>@])],
+ [ac_cv_enable_dtrace="yes"],
+ [ac_cv_enable_dtrace="no"])
+
+ AS_IF([test "$ac_cv_enable_dtrace" = "yes"],[
+ AC_CHECK_PROGS([DTRACE], [dtrace])
+ AS_IF([test "x$ac_cv_prog_DTRACE" = "xdtrace"],[
+ AC_DEFINE([HAVE_DTRACE], [1], [Enables DTRACE Support])
+ dnl DTrace on MacOSX does not use -G option
+ cat >conftest.d <<_ACEOF
+provider Example {
+ probe increment(int);
+};
+_ACEOF
+ $DTRACE -G -o conftest.d.o -s conftest.d 2>/dev/zero
+ AS_IF([test $? -eq 0],[ac_cv_dtrace_needs_objects=yes])
+ rm -f conftest.d.o conftest.d
+
+ AC_SUBST(DTRACEFLAGS) dnl TODO: test for -G on OSX
+ ac_cv_have_dtrace=yes
+ ])])
+
+AM_CONDITIONAL([HAVE_DTRACE], [test "x$ac_cv_have_dtrace" = "xyes"])
+AM_CONDITIONAL([DTRACE_NEEDS_OBJECTS],
+ [test "x$ac_cv_dtrace_needs_objects" = "xyes"])
+
+])
+dnl ---------------------------------------------------------------------------
+dnl End Macro: PANDORA_ENABLE_DTRACE
+dnl ---------------------------------------------------------------------------
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl If the user is on a Mac and didn't ask for a specific compiler
+dnl You're gonna get 4.2.
+AC_DEFUN([PANDORA_MAC_GCC42],
+ [AS_IF([test "$GCC" = "yes"],[
+ AS_IF([test "$host_vendor" = "apple" -a "x${ac_cv_env_CC_set}" = "x"],[
+ AS_IF([test -f /usr/bin/gcc-4.2],
+ [
+ CPP="/usr/bin/gcc-4.2 -E"
+ CC=/usr/bin/gcc-4.2
+ CXX=/usr/bin/g++-4.2
+ ])
+ ])
+ ])
+])
+
+dnl
+AC_DEFUN([PANDORA_ENSURE_GCC_VERSION],[
+ AC_REQUIRE([PANDORA_MAC_GCC42])
+ AC_CACHE_CHECK([if GCC is recent enough], [ac_cv_gcc_recent],
+ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#if !defined(__GNUC__) || (__GNUC__ < 4) || ((__GNUC__ >= 4) && (__GNUC_MINOR__ < 1))
+# error GCC is Too Old!
+#endif
+ ]])],
+ [ac_cv_gcc_recent=yes],
+ [ac_cv_gcc_recent=no])])
+ AS_IF([test "$ac_cv_gcc_recent" = "no" -a "$host_vendor" = "apple"],
+ AC_MSG_ERROR([Your version of GCC is too old. At least version 4.2 is required on OSX. You may need to install a version of XCode >= 3.1.2]))
+ AS_IF([test "$ac_cv_gcc_recent" = "no"],
+ AC_MSG_ERROR([Your version of GCC is too old. At least version 4.1 is required]))
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl PANDORA_HEADER_ASSERT
+dnl ----------------
+dnl Check whether to enable assertions.
+AC_DEFUN([PANDORA_HEADER_ASSERT],
+[
+ AC_MSG_CHECKING([whether to enable assertions])
+ AC_ARG_ENABLE([assert],
+ [AS_HELP_STRING([--disable-assert],
+ [Turn off assertions])],
+ [ac_cv_assert="no"],
+ [ac_cv_assert="yes"])
+ AC_MSG_RESULT([$ac_cv_assert])
+
+ AS_IF([test "$ac_cv_assert" = "yes"],
+ [AC_CHECK_HEADERS(assert.h)],
+ [AC_DEFINE(NDEBUG, 1, [Define to 1 if assertions should be disabled.])])
+])
+
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([PANDORA_LIBTOOL],[
+ AC_REQUIRE([AC_PROG_LIBTOOL])
+ dnl By requiring AC_PROG_LIBTOOL, we should force the macro system to read
+ dnl libtool.m4, where in 2.2 AC_PROG_LIBTOOL is an alias for LT_INIT
+ dnl Then, if we're on 2.2, we should have LT_LANG, so we'll call it.
+ m4_ifdef([LT_LANG],[
+ LT_LANG(C)
+ LT_LANG(C++)
+ ])
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([PANDORA_OPTIMIZE],[
+ dnl Build optimized or debug version ?
+ dnl First check for gcc and g++
+ AS_IF([test "$GCC" = "yes"],[
+
+ dnl The following is required for portable results of floating point
+ dnl calculations on PowerPC. The same must also be done for IA-64, but
+ dnl this options is missing in the IA-64 gcc backend.
+ case "$target_cpu" in
+ *ppc* | *powerpc*)
+ AM_CFLAGS="-mno-fused-madd ${AM_CFLAGS}"
+ AM_CXXFLAGS="-mno-fused-madd ${AM_CXXFLAGS}"
+ ;;
+ esac
+
+ dnl Once we can use a modern autoconf, we can replace the std=gnu99 here
+ dnl with using AC_CC_STD_C99 above
+ CC="${CC} -std=gnu99"
+
+ AM_CPPFLAGS="-ggdb3 ${AM_CPPFLAGS}"
+
+ DEBUG_CFLAGS="-O0"
+ DEBUG_CXXFLAGS="-O0"
+
+ OPTIMIZE_CFLAGS="-O3"
+ OPTIMIZE_CXXFLAGS="-O3"
+ ])
+ AS_IF([test "$SUNCC" = "yes"],[
+ dnl Once we can use a modern autoconf, we can replace the -xc99=all here
+ dnl with using AC_CC_STD_C99 above
+ CC="${CC} -xc99=all"
+ CXX="${CXX} -xlang=c99"
+
+ AM_CFLAGS="-g -mt -xstrconst -Xa ${AM_CFLAGS}"
+ AM_CXXFLAGS="-mt -compat=5 -library=stlport4 -template=no%extdef ${AM_CXXFLAGS}"
+
+ DEBUG_CXXFLAGS="-g"
+
+ dnl TODO: Make a test for -xO4 usability here
+ OPTIMIZE_FLAGS="-xO3 -xlibmil -xdepend -xbuiltin"
+ OPTIMIZE_CFLAGS="${OPTIMIZE_FLAGS}"
+ OPTIMIZE_CXXFLAGS="-g0 ${OPTIMIZE_FLAGS}"
+
+ ])
+
+ AC_ARG_WITH([debug],
+ [AS_HELP_STRING([--with-debug],
+ [Add debug code/turns off optimizations (yes|no) @<:@default=no@:>@])],
+ [with_debug=$withval],
+ [with_debug=no])
+ AS_IF([test "$with_debug" = "yes"],[
+ # Debugging. No optimization.
+ AM_CFLAGS="${AM_CFLAGS} ${DEBUG_CFLAGS} -DDEBUG"
+ AM_CXXFLAGS="${AM_CXXFLAGS} ${DEBUG_CXXFLAGS} -DDEBUG"
+ ],[
+ # Optimized version. No debug
+ AM_CFLAGS="${AM_CFLAGS} ${OPTIMIZE_CFLAGS}"
+ AM_CXXFLAGS="${AM_CXXFLAGS} ${OPTIMIZE_CXXFLAGS}"
+ ])
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl We check two things: where is the memory include file, and in what
+dnl namespace does shared_ptr reside.
+dnl We include AC_COMPILE_IFELSE for all the combinations we've seen in the
+dnl wild:
+dnl
+dnl GCC 4.3: namespace: std:: #include <memory>
+dnl GCC 4.2: namespace: tr1:: #include <tr1/memory>
+dnl GCC 4.2: namespace: boost:: #include <boost/shared_ptr.hpp>
+dnl
+dnl We define one of HAVE_HAVE_TR1_SHARED_PTR or HAVE_BOOST_SHARED_PTR
+dnl depending on location, and SHARED_PTR_NAMESPACE to be the namespace in
+dnl which shared_ptr is defined.
+dnl
+
+AC_DEFUN([PANDORA_SHARED_PTR],[
+ AC_REQUIRE([PANDORA_CHECK_CXX_STANDARD])
+ AC_LANG_PUSH(C++)
+ AC_CHECK_HEADERS(memory tr1/memory boost/shared_ptr.hpp)
+ AC_CACHE_CHECK([the location of shared_ptr header file],
+ [ac_cv_shared_ptr_h],[
+ for namespace in std tr1 std::tr1 boost
+ do
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([[
+#if defined(HAVE_MEMORY)
+# include <memory>
+#endif
+#if defined(HAVE_TR1_MEMORY)
+# include <tr1/memory>
+#endif
+#if defined(HAVE_BOOST_SHARED_PTR_HPP)
+# include <boost/shared_ptr.hpp>
+#endif
+#include <string>
+
+using $namespace::shared_ptr;
+using namespace std;
+ ]],[[
+shared_ptr<string> test_ptr(new string("test string"));
+ ]])],
+ [
+ ac_cv_shared_ptr_namespace="${namespace}"
+ break
+ ],[ac_cv_shared_ptr_namespace=missing])
+ done
+ ])
+ AC_DEFINE_UNQUOTED([SHARED_PTR_NAMESPACE],
+ ${ac_cv_shared_ptr_namespace},
+ [The namespace in which SHARED_PTR can be found])
+ AC_LANG_POP()
+])
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([PANDORA_BUILDING_FROM_VC],[
+
+ ac_cv_building_from_vc=no
+
+ AS_IF([test -d "${srcdir}/.bzr"],[
+ ac_cv_building_from_bzr=yes
+ ac_cv_building_from_vc=yes
+ ],[
+ ac_cv_building_from_bzr=no
+ ])
+
+ AS_IF([test -d "${srcdir}/.svn"],[
+ ac_cv_building_from_svn=yes
+ ac_cv_building_from_vc=yes
+ ],[
+ ac_cv_building_from_svn=no
+ ])
+
+ AS_IF([test -d "${srcdir}/.hg"],[
+ ac_cv_building_from_hg=yes
+ ac_cv_building_from_vc=yes
+ ],[
+ ac_cv_building_from_hg=no
+ ])
+
+])
+
--- /dev/null
+dnl Copyright (C) 2009 Sun Microsystems
+dnl This file is free software; Sun Microsystems
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl AC_PANDORA_WARNINGS([less-warnings|warnings-always-on])
+dnl less-warnings turn on a limited set of warnings
+dnl warnings-always-on always set warnings=error regardless of tarball/vc
+
+dnl @TODO: remove less-warnings option as soon as Drizzle is clean enough to
+dnl allow it
+
+AC_DEFUN([PANDORA_WARNINGS],[
+ m4_define([PW_LESS_WARNINGS],[no])
+ m4_define([PW_WARN_ALWAYS_ON],[no])
+ ifdef([m4_define],,[define([m4_define], defn([define]))])
+ ifdef([m4_undefine],,[define([m4_undefine], defn([undefine]))])
+ m4_foreach([pw_arg],[$*],[
+ m4_case(pw_arg,
+ [less-warnings],[
+ m4_undefine([PW_LESS_WARNINGS])
+ m4_define([PW_LESS_WARNINGS],[yes])
+ ],
+ [warnings-always-on],[
+ m4_undefine([PW_WARN_ALWAYS_ON])
+ m4_define([PW_WARN_ALWAYS_ON],[yes])
+ ])
+ ])
+
+ AC_REQUIRE([PANDORA_BUILDING_FROM_VC])
+ m4_if(PW_WARN_ALWAYS_ON, [yes],
+ [ac_cv_warnings_as_errors=yes],
+ AS_IF([test "$ac_cv_building_from_vc" = "yes"],
+ [ac_cv_warnings_as_errors=yes],
+ [ac_cv_warnings_as_errors=no]))
+
+ AC_ARG_ENABLE([profiling],
+ [AS_HELP_STRING([--enable-profiling],
+ [Toggle profiling @<:@default=off@:>@])],
+ [ac_profiling="$enableval"],
+ [ac_profiling="no"])
+
+ AC_ARG_ENABLE([coverage],
+ [AS_HELP_STRING([--enable-coverage],
+ [Toggle coverage @<:@default=off@:>@])],
+ [ac_coverage="$enableval"],
+ [ac_coverage="no"])
+
+ AS_IF([test "$GCC" = "yes"],[
+
+ AS_IF([test "$ac_profiling" = "yes"],[
+ CC_PROFILING="-pg"
+ save_LIBS="${LIBS}"
+ LIBS=""
+ AC_CHECK_LIB(c_p, read)
+ LIBC_P="${LIBS}"
+ LIBS="${save_LIBS}"
+ AC_SUBST(LIBC_P)
+ ],[
+ CC_PROFILING=" "
+ ])
+
+ AS_IF([test "$ac_coverage" = "yes"],
+ [CC_COVERAGE="-fprofile-arcs -ftest-coverage"])
+
+ AS_IF([test "$ac_cv_warnings_as_errors" = "yes"],
+ [W_FAIL="-Werror"])
+
+ AC_CACHE_CHECK([whether it is safe to use -fdiagnostics-show-option],
+ [ac_cv_safe_to_use_fdiagnostics_show_option_],
+ [save_CFLAGS="$CFLAGS"
+ CFLAGS="-fdiagnostics-show-option ${AM_CFLAGS} ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([],[])],
+ [ac_cv_safe_to_use_fdiagnostics_show_option_=yes],
+ [ac_cv_safe_to_use_fdiagnostics_show_option_=no])
+ CFLAGS="$save_CFLAGS"])
+
+ AS_IF([test "$ac_cv_safe_to_use_fdiagnostics_show_option_" = "yes"],
+ [
+ F_DIAGNOSTICS_SHOW_OPTION="-fdiagnostics-show-option"
+ ])
+
+ AC_CACHE_CHECK([whether it is safe to use -Wconversion],
+ [ac_cv_safe_to_use_wconversion_],
+ [save_CFLAGS="$CFLAGS"
+ dnl Use -Werror here instead of ${W_FAIL} so that we don't spew
+ dnl conversion warnings to all the tarball folks
+ CFLAGS="-Wconversion -Werror -pedantic ${AM_CFLAGS} ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([[
+#include <stdbool.h>
+void foo(bool a)
+{
+ (void)a;
+}
+ ]],[[
+foo(0);
+ ]])],
+ [ac_cv_safe_to_use_wconversion_=yes],
+ [ac_cv_safe_to_use_wconversion_=no])
+ CFLAGS="$save_CFLAGS"])
+
+ AS_IF([test "$ac_cv_safe_to_use_wconversion_" = "yes"],
+ [W_CONVERSION="-Wconversion"
+ AC_CACHE_CHECK([whether it is safe to use -Wconversion with htons],
+ [ac_cv_safe_to_use_Wconversion_],
+ [save_CFLAGS="$CFLAGS"
+ dnl Use -Werror here instead of ${W_FAIL} so that we don't spew
+ dnl conversion warnings to all the tarball folks
+ CFLAGS="-Wconversion -Werror -pedantic ${AM_CFLAGS} ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM(
+ [[
+#include <netinet/in.h>
+ ]],[[
+uint16_t x= htons(80);
+ ]])],
+ [ac_cv_safe_to_use_Wconversion_=yes],
+ [ac_cv_safe_to_use_Wconversion_=no])
+ CFLAGS="$save_CFLAGS"])
+
+ AS_IF([test "$ac_cv_safe_to_use_Wconversion_" = "no"],
+ [NO_CONVERSION="-Wno-conversion"])
+ ])
+
+ NO_STRICT_ALIASING="-fno-strict-aliasing -Wno-strict-aliasing"
+ NO_SHADOW="-Wno-shadow"
+
+ m4_if(PW_LESS_WARNINGS,[no],[
+ BASE_WARNINGS_FULL="-Wformat=2 ${W_CONVERSION} -Wstrict-aliasing"
+ CC_WARNINGS_FULL="-Wswitch-default -Wswitch-enum -Wwrite-strings"
+ CXX_WARNINGS_FULL="-Weffc++ -Wold-style-cast"
+ ],[
+ BASE_WARNINGS_FULL="-Wformat ${NO_STRICT_ALIASING}"
+ ])
+
+ AS_IF([test "${ac_cv_assert}" = "no"],
+ [NO_UNUSED="-Wno-unused-variable -Wno-unused-parameter"])
+
+ BASE_WARNINGS="${W_FAIL} -pedantic -Wall -Wextra -Wundef -Wshadow ${NO_UNUSED} ${F_DIAGNOSTICS_SHOW_OPTION} ${CFLAG_VISIBILITY} ${BASE_WARNINGS_FULL}"
+ CC_WARNINGS="${BASE_WARNINGS} -Wstrict-prototypes -Wmissing-prototypes -Wredundant-decls -Wmissing-declarations -Wcast-align ${CC_WARNINGS_FULL}"
+ CXX_WARNINGS="${BASE_WARNINGS} -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wno-long-long ${CXX_WARNINGS_FULL}"
+
+ AC_CACHE_CHECK([whether it is safe to use -Wmissing-declarations from C++],
+ [ac_cv_safe_to_use_Wmissing_declarations_],
+ [AC_LANG_PUSH(C++)
+ save_CXXFLAGS="$CXXFLAGS"
+ CXXFLAGS="-Werror -pedantic -Wmissing-declarations ${AM_CXXFLAGS}"
+ AC_COMPILE_IFELSE([
+ AC_LANG_PROGRAM(
+ [[
+#include <stdio.h>
+ ]], [[]])
+ ],
+ [ac_cv_safe_to_use_Wmissing_declarations_=yes],
+ [ac_cv_safe_to_use_Wmissing_declarations_=no])
+ CXXFLAGS="$save_CXXFLAGS"
+ AC_LANG_POP()
+ ])
+ AS_IF([test "$ac_cv_safe_to_use_Wmissing_declarations_" = "yes"],
+ [CXX_WARNINGS="${CXX_WARNINGS} -Wmissing-declarations"])
+
+ AC_CACHE_CHECK([whether it is safe to use -Wlogical-op],
+ [ac_cv_safe_to_use_Wlogical_op_],
+ [save_CFLAGS="$CFLAGS"
+ CFLAGS="${W_FAIL} -pedantic -Wlogical-op ${AM_CFLAGS} ${CFLAGS}"
+ AC_COMPILE_IFELSE([
+ AC_LANG_PROGRAM(
+ [[
+#include <stdio.h>
+ ]], [[]])
+ ],
+ [ac_cv_safe_to_use_Wlogical_op_=yes],
+ [ac_cv_safe_to_use_Wlogical_op_=no])
+ CFLAGS="$save_CFLAGS"])
+ AS_IF([test "$ac_cv_safe_to_use_Wlogical_op_" = "yes"],
+ [CC_WARNINGS="${CC_WARNINGS} -Wlogical-op"])
+
+ AC_CACHE_CHECK([whether it is safe to use -Wredundant-decls from C++],
+ [ac_cv_safe_to_use_Wredundant_decls_],
+ [AC_LANG_PUSH(C++)
+ save_CXXFLAGS="${CXXFLAGS}"
+ CXXFLAGS="${W_FAIL} -pedantic -Wredundant-decls ${AM_CXXFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([
+template <typename E> struct C { void foo(); };
+template <typename E> void C<E>::foo() { }
+template <> void C<int>::foo();
+ AC_INCLUDES_DEFAULT])],
+ [ac_cv_safe_to_use_Wredundant_decls_=yes],
+ [ac_cv_safe_to_use_Wredundant_decls_=no])
+ CXXFLAGS="${save_CXXFLAGS}"
+ AC_LANG_POP()])
+ AS_IF([test "$ac_cv_safe_to_use_Wredundant_decls_" = "yes"],
+ [CXX_WARNINGS="${CXX_WARNINGS} -Wredundant-decls"],
+ [CXX_WARNINGS="${CXX_WARNINGS} -Wno-redundant-decls"])
+
+ NO_REDUNDANT_DECLS="-Wno-redundant-decls"
+ PROTOSKIP_WARNINGS="-Wno-effc++ -Wno-shadow"
+
+ ])
+
+ AS_IF([test "$SUNCC" = "yes"],[
+
+ AS_IF([test "$ac_profiling" = "yes"],
+ [CC_PROFILING="-xinstrument=datarace"])
+
+ AS_IF([test "$ac_cv_warnings_as_errors" = "yes"],
+ [W_FAIL="-errwarn=%all"])
+
+ AC_CACHE_CHECK([whether E_PASTE_RESULT_NOT_TOKEN is usable],
+ [ac_cv_paste_result],
+ [
+ save_CFLAGS="${CFLAGS}"
+ CFLAGS="-errwarn=%all -erroff=E_PASTE_RESULT_NOT_TOKEN ${CFLAGS}"
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([
+ AC_INCLUDES_DEFAULT
+ ],[
+ int x= 0;])],
+ [ac_cv_paste_result=yes],
+ [ac_cv_paste_result=no])
+ CFLAGS="${save_CFLAGS}"
+ ])
+ AS_IF([test $ac_cv_paste_result = yes],
+ [W_PASTE_RESULT=",E_PASTE_RESULT_NOT_TOKEN"])
+
+
+ m4_if(PW_LESS_WARNINGS, [no],[
+ CC_WARNINGS_FULL="-erroff=E_INTEGER_OVERFLOW_DETECTED${W_PASTE_RESULT}"
+ ],[
+ CC_WARNINGS_FULL="-erroff=E_ATTRIBUTE_NOT_VAR"
+ CXX_WARNINGS_FULL="-erroff=attrskipunsup,doubunder,reftotemp,inllargeuse,truncwarn1,signextwarn,inllargeint"
+ ])
+
+ CC_WARNINGS="-v -errtags=yes ${W_FAIL} ${CC_WARNINGS_FULL}"
+ CXX_WARNINGS="+w +w2 -xwe -xport64 -errtags=yes ${CXX_WARNINGS_FULL} ${W_FAIL}"
+ PROTOSKIP_WARNINGS="-erroff=attrskipunsup,doubunder,reftotemp,wbadinitl,identexpected,inllargeuse,truncwarn1,signextwarn"
+ NO_UNREACHED="-erroff=E_STATEMENT_NOT_REACHED"
+
+ ])
+
+ AC_SUBST(NO_CONVERSION)
+ AC_SUBST(NO_REDUNDANT_DECLS)
+ AC_SUBST(NO_UNREACHED)
+ AC_SUBST(NO_SHADOW)
+ AC_SUBST(NO_STRICT_ALIASING)
+ AC_SUBST(PROTOSKIP_WARNINGS)
+
+])
--- /dev/null
+# visibility.m4 serial 2 (gettext-0.18)
+dnl Copyright (C) 2005, 2008 Free Software Foundation, Inc.
+dnl This file is free software; the Free Software Foundation
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl From Bruno Haible.
+
+dnl Tests whether the compiler supports the command-line option
+dnl -fvisibility=hidden and the function and variable attributes
+dnl __attribute__((__visibility__("hidden"))) and
+dnl __attribute__((__visibility__("default"))).
+dnl Does *not* test for __visibility__("protected") - which has tricky
+dnl semantics (see the 'vismain' test in glibc) and does not exist e.g. on
+dnl MacOS X.
+dnl Does *not* test for __visibility__("internal") - which has processor
+dnl dependent semantics.
+dnl Does *not* test for #pragma GCC visibility push(hidden) - which is
+dnl "really only recommended for legacy code".
+dnl Set the variable CFLAG_VISIBILITY.
+dnl Defines and sets the variable HAVE_VISIBILITY.
+
+AC_DEFUN([gl_VISIBILITY],
+[
+ AC_REQUIRE([AC_PROG_CC])
+ CFLAG_VISIBILITY=
+ HAVE_VISIBILITY=0
+ if test -n "$GCC"; then
+ AC_MSG_CHECKING([for simple visibility declarations])
+ AC_CACHE_VAL([gl_cv_cc_visibility], [
+ gl_save_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS -fvisibility=hidden"
+ AC_TRY_COMPILE(
+ [extern __attribute__((__visibility__("hidden"))) int hiddenvar;
+ extern __attribute__((__visibility__("default"))) int exportedvar;
+ extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void);
+ extern __attribute__((__visibility__("default"))) int exportedfunc (void);],
+ [],
+ [gl_cv_cc_visibility=yes],
+ [gl_cv_cc_visibility=no])
+ CFLAGS="$gl_save_CFLAGS"])
+ AC_MSG_RESULT([$gl_cv_cc_visibility])
+ if test $gl_cv_cc_visibility = yes; then
+ CFLAG_VISIBILITY="-fvisibility=hidden"
+ HAVE_VISIBILITY=1
+ fi
+ fi
+ AC_SUBST([CFLAG_VISIBILITY])
+ AC_SUBST([HAVE_VISIBILITY])
+ AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY],
+ [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.])
+])
noinst_HEADERS = test.h server.h ketama_test_cases.h
noinst_PROGRAMS = testapp testplus udptest atomsmasher startservers
+noinst_LTLIBRARIES= libserver.la libtest.la
-testapp_CFLAGS= ${AM_CFLAGS} ${NO_CONVERSION}
-testapp_SOURCES = test.c function.c server.c ../clients/generator.c ../clients/execute.c
-testapp_LDADD = $(LDADDS)
+libserver_la_SOURCES= server.c
+libtest_la_SOURCES= test.c
-testplus_SOURCES = test.c plus.cpp server.c
-testplus_LDADD = $(LDADDS)
+testapp_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING)
+testapp_SOURCES = function.c
+testapp_LDADD = $(LDADDS) $(top_builddir)/clients/libgenexec.la libtest.la libserver.la
-udptest_SOURCES = test.c udp.c server.c
-udptest_LDADD = $(LDADDS)
+testplus_SOURCES = plus.cpp
+testplus_LDADD = $(LDADDS) libtest.la libserver.la
-atomsmasher_SOURCES = test.c atomsmasher.c server.c ../clients/generator.c ../clients/execute.c
-atomsmasher_LDADD = $(LDADDS)
+udptest_SOURCES = udp.c
+udptest_LDADD = $(LDADDS) libtest.la libserver.la
-startservers_SOURCES = start.c server.c
-startservers_LDADD = $(LDADDS)
+atomsmasher_SOURCES = atomsmasher.c
+atomsmasher_LDADD = $(LDADDS) $(top_builddir)/clients/libgenexec.la libtest.la libserver.la
+
+startservers_SOURCES = start.c
+startservers_LDADD = $(LDADDS) libserver.la
record:
./testapp > output.res
libtool --mode=execute valgrind --tool=helgrind testapp
helgrind-slap:
- libtool --mode=execute valgrind --tool=helgrind ../clients/memslap --server=localhost --concurrency=30
+ libtool --mode=execute valgrind --tool=helgrind ${top_builddir}/clients/memslap --server=localhost --concurrency=30
test-no-outputdiff: testapp
./testapp > /dev/null
static test_return add_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
unsigned long long setting_value;
setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
/* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
if (setting_value)
- assert(rc == MEMCACHED_NOTSTORED || MEMCACHED_STORED);
+ assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
else
assert(rc == MEMCACHED_NOTSTORED);
/*
Sample test application.
*/
+
#include "libmemcached/common.h"
#include <assert.h>
static uint32_t global_count;
static pairs_st *global_pairs;
-static char *global_keys[GLOBAL_COUNT];
+static const char *global_keys[GLOBAL_COUNT];
static size_t global_keys_length[GLOBAL_COUNT];
static test_return init_test(memcached_st *not_used __attribute__((unused)))
static test_return set_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
static test_return append_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "fig";
- char *value= "we";
+ const char *key= "fig";
+ const char *in_value= "we";
+ char *out_value= NULL;
size_t value_length;
uint32_t flags;
assert(rc == MEMCACHED_SUCCESS);
rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
+ in_value, strlen(in_value),
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
- value= memcached_get(memc, key, strlen(key),
+ out_value= memcached_get(memc, key, strlen(key),
&value_length, &flags, &rc);
- assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(!memcmp(out_value, "we the people", strlen("we the people")));
assert(strlen("we the people") == value_length);
assert(rc == MEMCACHED_SUCCESS);
- free(value);
+ free(out_value);
return 0;
}
static test_return append_binary_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "numbers";
+ const char *key= "numbers";
unsigned int *store_ptr;
unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
char *value;
static test_return cas2_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
- char *value= "we the people";
+ const char *value= "we the people";
size_t value_length= strlen("we the people");
unsigned int x;
memcached_result_st results_obj;
assert(results);
assert(results->cas);
assert(rc == MEMCACHED_SUCCESS);
- WATCHPOINT_ASSERT(memcached_result_cas(results));
+ assert(memcached_result_cas(results));
assert(!memcmp(value, "we the people", strlen("we the people")));
assert(strlen("we the people") == value_length);
const char *key= "fun";
size_t key_length= strlen(key);
const char *value= "we the people";
- char* keys[2] = { (char*)key, NULL };
+ const char* keys[2] = { key, NULL };
size_t keylengths[2] = { strlen(key), 0 };
size_t value_length= strlen(value);
const char *value2= "change the value";
results= memcached_fetch_result(memc, &results_obj, &rc);
assert(results);
assert(rc == MEMCACHED_SUCCESS);
- WATCHPOINT_ASSERT(memcached_result_cas(results));
+ assert(memcached_result_cas(results));
assert(!memcmp(value, memcached_result_value(results), value_length));
assert(strlen(memcached_result_value(results)) == value_length);
assert(rc == MEMCACHED_SUCCESS);
static test_return prepend_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "fig";
- char *value= "people";
+ const char *key= "fig";
+ const char *value= "people";
+ char *out_value= NULL;
size_t value_length;
uint32_t flags;
(time_t)0, (uint32_t)0);
assert(rc == MEMCACHED_SUCCESS);
- value= memcached_get(memc, key, strlen(key),
+ out_value= memcached_get(memc, key, strlen(key),
&value_length, &flags, &rc);
- assert(!memcmp(value, "we the people", strlen("we the people")));
+ assert(!memcmp(out_value, "we the people", strlen("we the people")));
assert(strlen("we the people") == value_length);
assert(rc == MEMCACHED_SUCCESS);
- free(value);
+ free(out_value);
return 0;
}
static test_return add_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
unsigned long long setting_value;
setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
static test_return replace_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
- char *original= "first we insert some data";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ const char *original= "first we insert some data";
rc= memcached_set(memc, key, strlen(key),
original, strlen(original),
static test_return delete_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
static test_return memcached_server_cursor_test(memcached_st *memc)
{
- char *context= "foo bad";
+ char context[8];
+ strcpy(context, "foo bad");
memcached_server_function callbacks[1];
callbacks[0]= server_function;
memcached_server_cursor(memc, callbacks, context, 1);
-
return 0;
}
static test_return bad_key_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo bad";
+ const char *key= "foo bad";
char *string;
size_t string_length;
uint32_t flags;
assert(!string);
/* Test multi key for bad keys */
- char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
+ const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
size_t key_lengths[] = { 7, 7, 7 };
set= 1;
rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
static test_return read_through(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *string;
size_t string_length;
uint32_t flags;
static test_return get_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *string;
size_t string_length;
uint32_t flags;
static test_return get_test2(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
char *string;
size_t string_length;
uint32_t flags;
static test_return set_test2(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "train in the brain";
+ const char *key= "foo";
+ const char *value= "train in the brain";
size_t value_length= strlen(value);
unsigned int x;
static test_return get_test3(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 8191;
char *string;
static test_return get_test4(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 8191;
char *string;
** Request the same key twice, to ensure that we hash to the same server
** (so that we have multiple response values queued up) ;-)
*/
- char *keys[]= { "key", "key" };
+ const char *keys[]= { "key", "key" };
size_t lengths[]= { 3, 3 };
uint32_t flags;
size_t rlen;
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
- char *value= "0";
+ const char *key= "number";
+ const char *value= "0";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
+ const char *key= "number";
uint64_t initial= 0;
rc= memcached_increment_with_initial(memc, key, strlen(key),
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
- char *value= "3";
+ const char *key= "number";
+ const char *value= "3";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
{
uint64_t new_number;
memcached_return rc;
- char *key= "number";
+ const char *key= "number";
uint64_t initial= 3;
rc= memcached_decrement_with_initial(memc, key, strlen(key),
static test_return quit_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "fudge";
- char *value= "sanford and sun";
+ const char *key= "fudge";
+ const char *value= "sanford and sun";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
static test_return mget_result_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
static test_return mget_result_alloc_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
static test_return mget_result_function(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
unsigned int counter;
static test_return mget_test(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
uint32_t flags;
errors++;
else
{
- WATCHPOINT_ERROR(rc);
- assert(0);
+ assert(rc);
}
continue;
key_lengths[x]= strlen(keys[x]);
}
- rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
+ rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
assert(rc == MEMCACHED_SUCCESS);
/* Turn this into a help function */
static test_return user_supplied_bug4(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"fudge", "son", "food"};
+ const char *keys[]= {"fudge", "son", "food"};
size_t key_length[]= {5, 3, 4};
unsigned int x;
uint32_t flags;
static test_return user_supplied_bug5(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
char return_key[MEMCACHED_MAX_KEY];
size_t return_key_length;
static test_return user_supplied_bug6(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
char return_key[MEMCACHED_MAX_KEY];
size_t return_key_length;
memcached_st *memc_clone;
memcached_server_st *servers;
- char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
+ const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
servers= memcached_servers_parse(server_list);
assert(servers);
static test_return user_supplied_bug7(memcached_st *memc)
{
memcached_return rc;
- char *keys= "036790384900";
- size_t key_length= strlen("036790384900");
+ const char *keys= "036790384900";
+ size_t key_length= strlen(keys);
char return_key[MEMCACHED_MAX_KEY];
size_t return_key_length;
char *value;
static test_return user_supplied_bug9(memcached_st *memc)
{
memcached_return rc;
- char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
+ const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
size_t key_length[3];
unsigned int x;
uint32_t flags;
/* We are testing with aggressive timeout to get failures */
static test_return user_supplied_bug10(memcached_st *memc)
{
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 512;
unsigned int x;
*/
static test_return user_supplied_bug11(memcached_st *memc)
{
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 512;
unsigned int x;
size_t setter= 1;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
char *value;
size_t value_length= 18000;
char *string;
{
uint32_t x;
memcached_return rc;
- char *key= "mykey";
+ const char *key= "mykey";
char *value;
size_t length;
uint32_t flags;
static test_return user_supplied_bug16(memcached_st *memc)
{
memcached_return rc;
- char *key= "mykey";
+ const char *key= "mykey";
char *value;
size_t length;
uint32_t flags;
static test_return user_supplied_bug17(memcached_st *memc)
{
memcached_return rc;
- char *key= "豆瓣";
- char *value="我们在炎热抑郁的夏天无法停止豆瓣";
+ const char *key= "豆瓣";
+ const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
char *value2;
size_t length;
uint32_t flags;
{
memcached_return status;
memcached_result_st *result, result_obj;
- char *key = "abc";
+ const char *key = "abc";
size_t key_len = strlen("abc");
- char *value = "foobar";
+ const char *value = "foobar";
size_t value_len = strlen(value);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
return rc;
}
+static memcached_return pre_replication_noblock(memcached_st *memc)
+{
+ memcached_return rc= MEMCACHED_FAILURE;
+ if (pre_replication(memc) == MEMCACHED_SUCCESS &&
+ pre_nonblock(memc) == MEMCACHED_SUCCESS)
+ rc= MEMCACHED_SUCCESS;
+
+ return rc;
+}
+
static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
{
free(mem);
/* Set to Zero, and then Set to something too large */
{
- char *long_key;
+ char long_key[255];
+ memset(long_key, 0, 255);
+
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
assert(rc == MEMCACHED_SUCCESS);
/* Test a long key for failure */
/* TODO, extend test to determine based on setting, what result should be */
- long_key= "Thisismorethentheallottednumberofcharacters";
+ strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
//assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
assert(rc == MEMCACHED_SUCCESS);
/* Now test a key with spaces (which will fail from long key, since bad key is not set) */
- long_key= "This is more then the allotted number of characters";
+ strcpy(long_key, "This is more then the allotted number of characters");
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
assert(rc == MEMCACHED_SUCCESS);
- long_key= "dog cat";
+ strcpy(long_key, "dog cat");
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
}
/* Try setting an illegal cas value (should not return an error to
* the caller (because we don't expect a return message from the server)
*/
- char* keys[]= {"0"};
+ const char* keys[]= {"0"};
size_t lengths[]= {1};
size_t length;
uint32_t flags;
static test_return replication_set_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
- memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
assert(rc == MEMCACHED_SUCCESS);
+ /*
+ ** We are using the quiet commands to store the replicas, so we need
+ ** to ensure that all of them are processed before we can continue.
+ ** In the test we go directly from storing the object to trying to
+ ** receive the object from all of the different servers, so we
+ ** could end up in a race condition (the memcached server hasn't yet
+ ** processed the quiet command from the replication set when it process
+ ** the request from the other client (created by the clone)). As a
+ ** workaround for that we call memcached_quit to send the quit command
+ ** to the server and wait for the response ;-) If you use the test code
+ ** as an example for your own code, please note that you shouldn't need
+ ** to do this ;-)
+ */
+ memcached_quit(memc);
+
/*
** "bubba" should now be stored on all of our servers. We don't have an
** easy to use API to address each individual server, so I'll just iterate
char key[2]= { [0]= (char)x };
size_t len;
uint32_t flags;
- char *val= memcached_get_by_key(clone, key, 1, "bubba", 5,
+ char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
&len, &flags, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(val != NULL);
free(val);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
*/
for (uint32_t host= 0; host < memc->number_of_hosts; ++host)
{
- memcached_st *clone= memcached_clone(NULL, memc);
- clone->hosts[host].port= 0;
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memc_clone->hosts[host].port= 0;
for (int x= 'a'; x <= 'z'; ++x)
{
char key[2]= { [0]= (char)x };
size_t len;
uint32_t flags;
- char *val= memcached_get_by_key(clone, key, 1, "bubba", 5,
+ char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
&len, &flags, &rc);
assert(rc == MEMCACHED_SUCCESS);
assert(val != NULL);
free(val);
}
- memcached_free(clone);
+ memcached_free(memc_clone);
}
return TEST_SUCCESS;
static test_return replication_mget_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
- memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
- char *keys[]= { "bubba", "key1", "key2", "key3" };
+ const char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
for (int x=0; x< 4; ++x)
assert(rc == MEMCACHED_SUCCESS);
}
+ /*
+ ** We are using the quiet commands to store the replicas, so we need
+ ** to ensure that all of them are processed before we can continue.
+ ** In the test we go directly from storing the object to trying to
+ ** receive the object from all of the different servers, so we
+ ** could end up in a race condition (the memcached server hasn't yet
+ ** processed the quiet command from the replication set when it process
+ ** the request from the other client (created by the clone)). As a
+ ** workaround for that we call memcached_quit to send the quit command
+ ** to the server and wait for the response ;-) If you use the test code
+ ** as an example for your own code, please note that you shouldn't need
+ ** to do this ;-)
+ */
+ memcached_quit(memc);
+
/*
* Don't do the following in your code. I am abusing the internal details
* within the library, and this is not a supported interface.
* This is to verify correct behavior in the library
*/
memcached_result_st result_obj;
- for (uint32_t host= 0; host < clone->number_of_hosts; host++)
+ for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
{
memcached_st *new_clone= memcached_clone(NULL, memc);
new_clone->hosts[host].port= 0;
for (int x= 'a'; x <= 'z'; ++x)
{
- char key[2]= { [0]= (char)x };
+ const char key[2]= { [0]= (const char)x };
rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_SUCCESS);
static test_return replication_delete_test(memcached_st *memc)
{
memcached_return rc;
- memcached_st *clone= memcached_clone(NULL, memc);
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
/* Delete the items from all of the servers except 1 */
uint64_t repl= memcached_behavior_get(memc,
MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
- char *keys[]= { "bubba", "key1", "key2", "key3" };
+ const char *keys[]= { "bubba", "key1", "key2", "key3" };
size_t len[]= { 5, 4, 4, 4 };
for (int x=0; x< 4; ++x)
uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
for (uint32_t x= 0; x < (repl + 1); ++x)
{
- clone->hosts[hash].port= 0;
- if (++hash == clone->number_of_hosts)
+ memc_clone->hosts[hash].port= 0;
+ if (++hash == memc_clone->number_of_hosts)
hash= 0;
}
memcached_result_st result_obj;
- for (uint32_t host= 0; host < clone->number_of_hosts; ++host)
+ for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
{
for (int x= 'a'; x <= 'z'; ++x)
{
- char key[2]= { [0]= (char)x };
+ const char key[2]= { [0]= (const char)x };
- rc= memcached_mget_by_key(clone, key, 1, keys, len, 4);
+ rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
assert(rc == MEMCACHED_SUCCESS);
- memcached_result_st *results= memcached_result_create(clone, &result_obj);
+ memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
assert(results);
int hits= 0;
- while ((results= memcached_fetch_result(clone, &result_obj, &rc)) != NULL)
+ while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
{
++hits;
}
memcached_result_free(&result_obj);
}
}
- memcached_free(clone);
+ memcached_free(memc_clone);
return TEST_SUCCESS;
}
for (x= 0; x < num_iters;x++)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
uint16_t *expected_ids= get_udp_request_ids(memc);
unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
size_t init_offset= memc->hosts[server_key].write_buffer_offset;
static test_return udp_set_too_big_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "bar";
+ const char *key= "bar";
char value[MAX_UDP_DATAGRAM_LENGTH];
uint16_t *expected_ids= get_udp_request_ids(memc);
rc= memcached_set(memc, key, strlen(key),
for (x= 0; x < num_iters;x++)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
uint16_t *expected_ids=get_udp_request_ids(memc);
unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
size_t init_offset= memc->hosts[server_key].write_buffer_offset;
static test_return udp_incr_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "incr";
- char *value= "1";
+ const char *key= "incr";
+ const char *value= "1";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
static test_return udp_decr_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "decr";
- char *value= "1";
+ const char *key= "decr";
+ const char *value= "1";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
(time_t)0, (uint32_t)0);
static test_return udp_get_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
+ const char *key= "foo";
size_t vlen;
uint16_t *expected_ids = get_udp_request_ids(memc);
char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
return TEST_SUCCESS;
}
-static char *list[]=
+static const char *list[]=
{
"apple",
"beat",
static test_return md5_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 3195025439, 2556848621, 3724893440, 3332385401, 245758794, 2550894432,
- 121710495, 3053817768, 1250994555, 1862072655, 2631955953, 2951528551,
- 1451250070, 2820856945, 2060845566, 3646985608, 2138080750, 217675895,
- 2230934345, 1234361223, 3968582726, 2455685270, 1293568479, 199067604,
- 2042482093 };
+ const char **ptr;
+ uint32_t values[]= { 3195025439U, 2556848621U, 3724893440U, 3332385401U,
+ 245758794U, 2550894432U, 121710495U, 3053817768U,
+ 1250994555U, 1862072655U, 2631955953U, 2951528551U,
+ 1451250070U, 2820856945U, 2060845566U, 3646985608U,
+ 2138080750U, 217675895U, 2230934345U, 1234361223U,
+ 3968582726U, 2455685270U, 1293568479U, 199067604U,
+ 2042482093U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
static test_return crc_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 10542, 22009, 14526, 19510, 19432, 10199, 20634, 9369, 11511, 10362,
- 7893, 31289, 11313, 9354, 7621, 30628, 15218, 25967, 2695, 9380,
- 17300, 28156, 9192, 20484, 16925 };
+ const char **ptr;
+ uint32_t values[]= { 10542U, 22009U, 14526U, 19510U, 19432U, 10199U, 20634U,
+ 9369U, 11511U, 10362U, 7893U, 31289U, 11313U, 9354U,
+ 7621U, 30628U, 15218U, 25967U, 2695U, 9380U,
+ 17300U, 28156U, 9192U, 20484U, 16925U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
{
static test_return fnv1_64_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
- 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
- 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
- 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
- 1801941682 };
+ const char **ptr;
+ uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
+ 1722477987U, 2991193800U, 4147007314U, 3633179701U,
+ 1805162104U, 3503289120U, 3395702895U, 3325073042U,
+ 2345265314U, 3340346032U, 2722964135U, 1173398992U,
+ 2815549194U, 2562818319U, 224996066U, 2680194749U,
+ 3035305390U, 246890365U, 2395624193U, 4145193337U,
+ 1801941682U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
{
static test_return fnv1a_64_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 1488911807, 2500855813, 1510099634, 1390325195, 3647689787, 3241528582,
- 1669328060, 2604311949, 734810122, 1516407546, 560948863, 1767346780,
- 561034892, 4156330026, 3716417003, 3475297030, 1518272172, 227211583,
- 3938128828, 126112909, 3043416448, 3131561933, 1328739897, 2455664041,
- 2272238452 };
+ const char **ptr;
+ uint32_t values[]= { 1488911807U, 2500855813U, 1510099634U, 1390325195U,
+ 3647689787U, 3241528582U, 1669328060U, 2604311949U,
+ 734810122U, 1516407546U, 560948863U, 1767346780U,
+ 561034892U, 4156330026U, 3716417003U, 3475297030U,
+ 1518272172U, 227211583U, 3938128828U, 126112909U,
+ 3043416448U, 3131561933U, 1328739897U, 2455664041U,
+ 2272238452U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
{
static test_return fnv1_32_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 67176023, 1190179409, 2043204404, 3221866419, 2567703427, 3787535528, 4147287986,
- 3500475733, 344481048, 3865235296, 2181839183, 119581266, 510234242, 4248244304,
- 1362796839, 103389328, 1449620010, 182962511, 3554262370, 3206747549, 1551306158,
- 4127558461, 1889140833, 2774173721, 1180552018 };
+ const char **ptr;
+ uint32_t values[]= { 67176023U, 1190179409U, 2043204404U, 3221866419U,
+ 2567703427U, 3787535528U, 4147287986U, 3500475733U,
+ 344481048U, 3865235296U, 2181839183U, 119581266U,
+ 510234242U, 4248244304U, 1362796839U, 103389328U,
+ 1449620010U, 182962511U, 3554262370U, 3206747549U,
+ 1551306158U, 4127558461U, 1889140833U, 2774173721U,
+ 1180552018U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
static test_return fnv1a_32_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 280767167, 2421315013, 3072375666, 855001899, 459261019, 3521085446, 18738364,
- 1625305005, 2162232970, 777243802, 3323728671, 132336572, 3654473228, 260679466,
- 1169454059, 2698319462, 1062177260, 235516991, 2218399068, 405302637, 1128467232,
- 3579622413, 2138539289, 96429129, 2877453236 };
+ const char **ptr;
+ uint32_t values[]= { 280767167U, 2421315013U, 3072375666U, 855001899U,
+ 459261019U, 3521085446U, 18738364U, 1625305005U,
+ 2162232970U, 777243802U, 3323728671U, 132336572U,
+ 3654473228U, 260679466U, 1169454059U, 2698319462U,
+ 1062177260U, 235516991U, 2218399068U, 405302637U,
+ 1128467232U, 3579622413U, 2138539289U, 96429129U,
+ 2877453236U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
{
static test_return hsieh_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
+ const char **ptr;
#ifdef HAVE_HSIEH_HASH
uint32_t values[]= { 3738850110, 3636226060, 3821074029, 3489929160, 3485772682, 80540287,
1805464076, 1895033657, 409795758, 979934958, 3634096985, 1284445480,
static test_return murmur_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 473199127, 4148981457, 3971873300, 3257986707, 1722477987, 2991193800,
- 4147007314, 3633179701, 1805162104, 3503289120, 3395702895, 3325073042,
- 2345265314, 3340346032, 2722964135, 1173398992, 2815549194, 2562818319,
- 224996066, 2680194749, 3035305390, 246890365, 2395624193, 4145193337,
- 1801941682 };
+ const char **ptr;
+ uint32_t values[]= { 473199127U, 4148981457U, 3971873300U, 3257986707U,
+ 1722477987U, 2991193800U, 4147007314U, 3633179701U,
+ 1805162104U, 3503289120U, 3395702895U, 3325073042U,
+ 2345265314U, 3340346032U, 2722964135U, 1173398992U,
+ 2815549194U, 2562818319U, 224996066U, 2680194749U,
+ 3035305390U, 246890365U, 2395624193U, 4145193337U,
+ 1801941682U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
{
static test_return jenkins_run (memcached_st *memc __attribute__((unused)))
{
uint32_t x;
- char **ptr;
- uint32_t values[]= { 1442444624, 4253821186, 1885058256, 2120131735, 3261968576, 3515188778,
- 4232909173, 4288625128, 1812047395, 3689182164, 2502979932, 1214050606,
- 2415988847, 1494268927, 1025545760, 3920481083, 4153263658, 3824871822,
- 3072759809, 798622255, 3065432577, 1453328165, 2691550971, 3408888387,
- 2629893356 };
+ const char **ptr;
+ uint32_t values[]= { 1442444624U, 4253821186U, 1885058256U, 2120131735U,
+ 3261968576U, 3515188778U, 4232909173U, 4288625128U,
+ 1812047395U, 3689182164U, 2502979932U, 1214050606U,
+ 2415988847U, 1494268927U, 1025545760U, 3920481083U,
+ 4153263658U, 3824871822U, 3072759809U, 798622255U,
+ 3065432577U, 1453328165U, 2691550971U, 3408888387U,
+ 2629893356U };
for (ptr= list, x= 0; *ptr; ptr++, x++)
{"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
{"test_hashes", 0, 0, hash_tests},
{"replication", pre_replication, 0, replication_tests},
+ {"replication_noblock", pre_replication_noblock, 0, replication_tests},
{0, 0, 0, 0}
};
typedef struct {
- char *key;
+ const char *key;
unsigned long hash1;
unsigned long hash2;
- char *server;
+ const char *server;
} TestCase;
static TestCase test_cases[99] = {
Error 34 -> THE HOST TRANSPORT PROTOCOL DOES NOT MATCH THAT OF THE CLIENT
Error 35 -> SERVER IS MARKED DEAD
Error 36 -> ENCOUNTERED AN UNKNOWN STAT KEY
+Error 0 -> SUCCESS
+Error 1 -> FAILURE
+Error 2 -> HOSTNAME LOOKUP FAILURE
+Error 3 -> CONNECTION FAILURE
+Error 4 -> CONNECTION BIND FAILURE
+Error 5 -> WRITE FAILURE
+Error 6 -> READ FAILURE
+Error 7 -> UNKNOWN READ FAILURE
+Error 8 -> PROTOCOL ERROR
+Error 9 -> CLIENT ERROR
+Error 10 -> SERVER ERROR
+Error 11 -> CONNECTION SOCKET CREATE FAILURE
+Error 12 -> CONNECTION DATA EXISTS
+Error 13 -> CONNECTION DATA DOES NOT EXIST
+Error 14 -> NOT STORED
+Error 15 -> STORED
+Error 16 -> NOT FOUND
+Error 17 -> MEMORY ALLOCATION FAILURE
+Error 18 -> PARTIAL READ
+Error 19 -> SOME ERRORS WERE REPORTED
+Error 20 -> NO SERVERS DEFINED
+Error 21 -> SERVER END
+Error 22 -> SERVER DELETE
+Error 23 -> SERVER VALUE
+Error 24 -> STAT VALUE
+Error 25 -> ITEM VALUE
+Error 26 -> SYSTEM ERROR
+Error 27 -> COULD NOT OPEN UNIX SOCKET
+Error 28 -> ACTION NOT SUPPORTED
+Error 29 -> A KEY LENGTH OF ZERO WAS PROVIDED
+Error 30 -> FETCH WAS NOT COMPLETED
+Error 31 -> A TIMEOUT OCCURRED
+Error 32 -> ACTION QUEUED
+Error 33 -> A BAD KEY WAS PROVIDED/CHARACTERS OUT OF RANGE
+Error 34 -> THE HOST TRANSPORT PROTOCOL DOES NOT MATCH THAT OF THE CLIENT
+Error 35 -> SERVER IS MARKED DEAD
+Error 36 -> ENCOUNTERED AN UNKNOWN STAT KEY
#include "test.h"
+#include <string>
+
+using namespace std;
+
extern "C" {
- test_return basic_test(memcached_st *memc);
- uint8_t increment_test(memcached_st *memc);
- test_return basic_master_key_test(memcached_st *memc);
void *world_create(void);
void world_destroy(void *p);
}
-test_return basic_test(memcached_st *memc)
+static test_return basic_test(memcached_st *memc)
{
Memcached foo(memc);
- const char *value_set= "This is some data";
- char *value;
+ const string value_set("This is some data");
+ string value;
size_t value_length;
- foo.set("mine", value_set, strlen(value_set));
+ foo.set("mine", value_set, 0, 0);
value= foo.get("mine", &value_length);
- assert((memcmp(value, value_set, value_length) == 0));
+ assert((memcmp(value.c_str(), value_set.c_str(), value_length) == 0));
return TEST_SUCCESS;
}
-uint8_t increment_test(memcached_st *memc)
+static test_return increment_test(memcached_st *memc)
{
Memcached mcach(memc);
- memcached_return rc;
- const char *key= "inctest";
- const char *inc_value= "1";
- char *ret_value;
+ bool rc;
+ const string key("inctest");
+ const string inc_value("1");
+ string ret_value;
uint64_t int_inc_value;
uint64_t int_ret_value;
size_t value_length;
- mcach.set(key, inc_value, strlen(inc_value));
+ mcach.set(key, inc_value, 0, 0);
ret_value= mcach.get(key, &value_length);
- printf("\nretvalue %s\n",ret_value);
- int_inc_value= atoi(inc_value);
- int_ret_value= atoi(ret_value);
+ printf("\nretvalue %s\n",ret_value.c_str());
+ int_inc_value= uint64_t(atol(inc_value.c_str()));
+ int_ret_value= uint64_t(atol(ret_value.c_str()));
assert(int_ret_value == int_inc_value);
rc= mcach.increment(key, 1, &int_ret_value);
- assert(rc == MEMCACHED_SUCCESS);
+ assert(rc == true);
assert(int_ret_value == 2);
rc= mcach.increment(key, 1, &int_ret_value);
- assert(rc == MEMCACHED_SUCCESS);
+ assert(rc == true);
assert(int_ret_value == 3);
rc= mcach.increment(key, 5, &int_ret_value);
- assert(rc == MEMCACHED_SUCCESS);
+ assert(rc == true);
assert(int_ret_value == 8);
- return 0;
+ return TEST_SUCCESS;
}
-test_return basic_master_key_test(memcached_st *memc)
+static test_return basic_master_key_test(memcached_st *memc)
{
- Memcached foo(memc);
- const char *value_set= "Data for server A";
- const char *master_key_a= "server-a";
- const char *master_key_b= "server-b";
- const char *key= "xyz";
- char *value;
+ Memcached foo(memc);
+ const string value_set("Data for server A");
+ const string master_key_a("server-a");
+ const string master_key_b("server-b");
+ const string key("xyz");
+ string value;
size_t value_length;
- foo.set_by_key(master_key_a, key, value_set, strlen(value_set));
+ foo.set_by_key(master_key_a, key, value_set, 0, 0);
value= foo.get_by_key(master_key_a, key, &value_length);
- assert((memcmp(value, value_set, value_length) == 0));
+ assert((memcmp(value.c_str(), value_set.c_str(), value_length) == 0));
value= foo.get_by_key(master_key_b, key, &value_length);
- assert((memcmp(value, value_set, value_length) == 0));
+ assert((memcmp(value.c_str(), value_set.c_str(), value_length) == 0));
+
+ return TEST_SUCCESS;
+}
+
+/* Count the results */
+static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
+ memcached_result_st *result __attribute__((unused)),
+ void *context)
+{
+ unsigned int *counter= static_cast<unsigned int *>(context);
+
+ *counter= *counter + 1;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return mget_result_function(memcached_st *memc)
+{
+ Memcached mc(memc);
+ bool rc;
+ string key1("fudge");
+ string key2("son");
+ string key3("food");
+ vector<string> keys;
+ keys.reserve(3);
+ keys.push_back(key1);
+ keys.push_back(key2);
+ keys.push_back(key3);
+ unsigned int counter;
+ memcached_execute_function callbacks[1];
+
+ /* We need to empty the server before we continue the test */
+ rc= mc.flush(0);
+ rc= mc.set_all(keys, keys, 50, 9);
+ assert(rc == true);
+
+ rc= mc.mget(keys);
+ assert(rc == true);
+
+ callbacks[0]= &callback_counter;
+ counter= 0;
+ rc= mc.fetch_execute(callbacks, static_cast<void *>(&counter), 1);
+
+ assert(counter == 3);
return TEST_SUCCESS;
}
+static test_return mget_test(memcached_st *memc)
+{
+ Memcached mc(memc);
+ bool rc;
+ memcached_return mc_rc;
+ vector<string> keys;
+ keys.reserve(3);
+ keys.push_back("fudge");
+ keys.push_back("son");
+ keys.push_back("food");
+ uint32_t flags;
+
+ string return_key;
+ size_t return_key_length;
+ string return_value;
+ size_t return_value_length;
+
+ /* We need to empty the server before we continue the test */
+ rc= mc.flush(0);
+ assert(rc == true);
+
+ rc= mc.mget(keys);
+ assert(rc == true);
+
+ while (mc.fetch(return_key, return_value, &return_key_length,
+ &return_value_length, &flags, &mc_rc))
+ {
+ assert(return_value.length() != 0);
+ }
+ assert(return_value_length == 0);
+ assert(mc_rc == MEMCACHED_END);
+
+ rc= mc.set_all(keys, keys, 50, 9);
+ assert(rc == true);
+
+ rc= mc.mget(keys);
+ assert(rc == true);
+
+ while ((mc.fetch(return_key, return_value, &return_key_length,
+ &return_value_length, &flags, &mc_rc)))
+ {
+ assert(return_value.length() != 0);
+ assert(mc_rc == MEMCACHED_SUCCESS);
+ assert(return_key_length == return_value_length);
+ assert(!memcmp(return_value.c_str(), return_key.c_str(), return_value_length));
+ }
+
+ return TEST_SUCCESS;
+}
test_st tests[] ={
- {"basic", 0, basic_test },
- {"basic_master_key", 0, basic_master_key_test },
+ { "basic", 0, basic_test },
+ { "basic_master_key", 0, basic_master_key_test },
+ { "increment_test", 0, increment_test },
+ { "mget", 1, mget_test },
+ { "mget_result_function", 1, mget_result_function },
{0, 0, 0}
};
#define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT+10
-#include "libmemcached/libmemcached_config.h"
+#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#endif
#include <libmemcached/memcached.h>
-#include "../libmemcached/common.h"
+#include <stdio.h>
typedef struct world_st world_st;
typedef struct collection_st collection_st;
test_return set_test(memcached_st *memc)
{
memcached_return rc;
- char *key= "foo";
- char *value= "when we sanitize";
+ const char *key= "foo";
+ const char *value= "when we sanitize";
rc= memcached_set(memc, key, strlen(key),
value, strlen(value),
projects / awesomized / libmemcached / commitdiff
