. , , ... are substituted in and with
# values found in , , ... respectively. ,
# , ... contain a list of possible values for each corresponding
# tag and all combinations are tested. When AC_TRY_COMPILE(include, code)
# is successfull for a given substitution, the macro stops and defines the
# following macros: FUNCTION_TAG1, FUNCTION_TAG2, ... using AC_DEFINE()
# with values set to the current values of , , ... If no
# combination is successfull the configure script is aborted with a
# message.
#
# Intended purpose is to find which combination of argument types is
# acceptable for a given function . It is recommended to list
# the most specific types first. For instance ARG1, [size_t, int] instead
# of ARG1, [int, size_t].
#
# Generic usage pattern:
#
# 1) add a call in configure.in
#
# AX_PROTOTYPE(...)
#
# 2) call autoheader to see which symbols are not covered
#
# 3) add the lines in acconfig.h
#
# /* Type of Nth argument of function */
# #undef FUNCTION_ARGN
#
# 4) Within the code use FUNCTION_ARGN instead of an hardwired type
#
# Complete example:
#
# 1) configure.in
#
# AX_PROTOTYPE(getpeername,
# [
# #include
# #include
# ],
# [
# int a = 0;
# ARG2 * b = 0;
# ARG3 * c = 0;
# getpeername(a, b, c);
# ],
# ARG2, [struct sockaddr, void],
# ARG3, [socklen_t, size_t, int, unsigned int, long unsigned int])
#
# 2) call autoheader
#
# autoheader: Symbol `GETPEERNAME_ARG2' is not covered by ./acconfig.h
# autoheader: Symbol `GETPEERNAME_ARG3' is not covered by ./acconfig.h
#
# 3) acconfig.h
#
# /* Type of second argument of getpeername */
# #undef GETPEERNAME_ARG2
#
# /* Type of third argument of getpeername */
# #undef GETPEERNAME_ARG3
#
# 4) in the code
#
# ...
# GETPEERNAME_ARG2 name;
# GETPEERNAME_ARG3 namelen;
# ...
# ret = getpeername(socket, &name, &namelen);
# ...
#
# Implementation notes: generating all possible permutations of the
# arguments is not easily done with the usual mixture of shell and m4,
# that is why this macro is almost 100% m4 code. It generates long but
# simple to read code.
#
# LICENSE
#
# Copyright (c) 2009 Loic Dachary
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see
dnl
AC_DEFUN([AX_PROTOTYPE_REVERSE],[ifelse($#,0,,$#,1,[[$1]],[AX_PROTOTYPE_REVERSE(builtin([shift],$@)),[$1]])])
dnl
dnl AX_PROTOTYPE_SUBST(string, tag)
dnl
dnl Substitute all occurence of in with _VAL.
dnl Assumes that tag_VAL is a macro containing the value associated to tag.
dnl
AC_DEFUN([AX_PROTOTYPE_SUBST],[ifelse($2,,[$1],[AX_PROTOTYPE_SUBST(patsubst([$1],[$2],[$2[]_VAL]),builtin([shift],builtin([shift],$@)))])])
dnl
dnl AX_PROTOTYPE_TAGS([tag, values, [tag, values ...]])
dnl
dnl Generate a list of by skipping .
dnl
AC_DEFUN([AX_PROTOTYPE_TAGS],[ifelse($1,,[],[$1, AX_PROTOTYPE_TAGS(builtin([shift],builtin([shift],$@)))])])
dnl
dnl AX_PROTOTYPE_DEFINES(tags)
dnl
dnl Generate a AC_DEFINE(function_tag, tag_VAL) for each tag in list
dnl Assumes that function is a macro containing the name of the function in upper case
dnl and that tag_VAL is a macro containing the value associated to tag.
dnl
AC_DEFUN([AX_PROTOTYPE_DEFINES],[ifelse($1,,[],
[AC_DEFINE(function[]_$1, $1_VAL, [ ])
AC_SUBST(function[]_$1, "$1_VAL")
AX_PROTOTYPE_DEFINES(builtin([shift],$@))])])
dnl
dnl AX_PROTOTYPE_STATUS(tags)
dnl
dnl Generates a message suitable for argument to AC_MSG_* macros. For each tag
dnl in the list the message tag => tag_VAL is generated.
dnl Assumes that tag_VAL is a macro containing the value associated to tag.
dnl
AC_DEFUN([AX_PROTOTYPE_STATUS],[ifelse($1,,[],[$1 => $1_VAL AX_PROTOTYPE_STATUS(builtin([shift],$@))])])
dnl
dnl AX_PROTOTYPE_EACH(tag, values)
dnl
dnl Call AX_PROTOTYPE_LOOP for each values and define the macro tag_VAL to
dnl the current value.
dnl
AC_DEFUN([AX_PROTOTYPE_EACH],[
ifelse($2,, [
], [
pushdef([$1_VAL], $2)
AX_PROTOTYPE_LOOP(rest)
popdef([$1_VAL])
AX_PROTOTYPE_EACH($1, builtin([shift], builtin([shift], $@)))
])
])
dnl
dnl AX_PROTOTYPE_LOOP([tag, values, [tag, values ...]], code, include, function)
dnl
dnl If there is a tag/values pair, call AX_PROTOTYPE_EACH with it.
dnl If there is no tag/values pair left, tries to compile the code and include
dnl using AC_TRY_COMPILE. If it compiles, AC_DEFINE all the tags to their
dnl current value and exit with success.
dnl
AC_DEFUN([AX_PROTOTYPE_LOOP],[
ifelse(builtin([eval], $# > 3), 1,
[
pushdef([rest],[builtin([shift],builtin([shift],$@))])
AX_PROTOTYPE_EACH($2,$1)
popdef([rest])
], [
AC_MSG_CHECKING($3 AX_PROTOTYPE_STATUS(tags))
dnl
dnl Activate fatal warnings if possible, gives better guess
dnl
ac_save_CPPFLAGS="$CPPFLAGS"
if test "$GCC" = "yes" ; then CPPFLAGS="$CPPFLAGS -Werror" ; fi
AC_TRY_COMPILE($2, $1, [
CPPFLAGS="$ac_save_CPPFLAGS"
AC_MSG_RESULT(ok)
AX_PROTOTYPE_DEFINES(tags)
break;
], [
CPPFLAGS="$ac_save_CPPFLAGS"
AC_MSG_RESULT(not ok)
])
]
)
])
libmongoc-1.9.2+dfsg/build/autotools/m4/ax_pthread.m4 0000664 0000000 0000000 00000032676 13226174053 0022465 0 ustar 00root root 0000000 0000000 # ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_pthread.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
#
# DESCRIPTION
#
# This macro figures out how to build C programs using POSIX threads. It
# sets the PTHREAD_LIBS output variable to the threads library and linker
# flags, and the PTHREAD_CFLAGS output variable to any special C compiler
# flags that are needed. (The user can also force certain compiler
# flags/libs to be tested by setting these environment variables.)
#
# Also sets PTHREAD_CC to any special C compiler that is needed for
# multi-threaded programs (defaults to the value of CC otherwise). (This
# is necessary on AIX to use the special cc_r compiler alias.)
#
# NOTE: You are assumed to not only compile your program with these flags,
# but also link it with them as well. e.g. you should link with
# $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
#
# If you are only building threads programs, you may wish to use these
# variables in your default LIBS, CFLAGS, and CC:
#
# LIBS="$PTHREAD_LIBS $LIBS"
# CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# CC="$PTHREAD_CC"
#
# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
# has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name
# (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
#
# Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
# PTHREAD_PRIO_INHERIT symbol is defined when compiling with
# PTHREAD_CFLAGS.
#
# ACTION-IF-FOUND is a list of shell commands to run if a threads library
# is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
# is not found. If ACTION-IF-FOUND is not specified, the default action
# will define HAVE_PTHREAD.
#
# Please let the authors know if this macro fails on any platform, or if
# you have any other suggestions or comments. This macro was based on work
# by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
# from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
# Alejandro Forero Cuervo to the autoconf macro repository. We are also
# grateful for the helpful feedback of numerous users.
#
# Updated for Autoconf 2.68 by Daniel Richard G.
#
# LICENSE
#
# Copyright (c) 2008 Steven G. Johnson
# Copyright (c) 2011 Daniel Richard G.
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see
static void routine(void *a) { a = 0; }
static void *start_routine(void *a) { return a; }],
[pthread_t th; pthread_attr_t attr;
pthread_create(&th, 0, start_routine, 0);
pthread_join(th, 0);
pthread_attr_init(&attr);
pthread_cleanup_push(routine, 0);
pthread_cleanup_pop(0) /* ; */])],
[ax_pthread_ok=yes],
[])
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
AC_MSG_RESULT([$ax_pthread_ok])
if test "x$ax_pthread_ok" = xyes; then
break;
fi
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
done
fi
# Various other checks:
if test "x$ax_pthread_ok" = xyes; then
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
AC_MSG_CHECKING([for joinable pthread attribute])
attr_name=unknown
for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ],
[int attr = $attr; return attr /* ; */])],
[attr_name=$attr; break],
[])
done
AC_MSG_RESULT([$attr_name])
if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], [$attr_name],
[Define to necessary symbol if this constant
uses a non-standard name on your system.])
fi
AC_MSG_CHECKING([if more special flags are required for pthreads])
flag=no
case ${host_os} in
aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";;
osf* | hpux*) flag="-D_REENTRANT";;
solaris*)
if test "$GCC" = "yes"; then
flag="-D_REENTRANT"
else
# TODO: What about Clang on Solaris?
flag="-mt -D_REENTRANT"
fi
;;
esac
AC_MSG_RESULT([$flag])
if test "x$flag" != xno; then
PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
fi
AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
[ax_cv_PTHREAD_PRIO_INHERIT], [
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]],
[[int i = PTHREAD_PRIO_INHERIT;]])],
[ax_cv_PTHREAD_PRIO_INHERIT=yes],
[ax_cv_PTHREAD_PRIO_INHERIT=no])
])
AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],
[AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])])
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
# More AIX lossage: compile with *_r variant
if test "x$GCC" != xyes; then
case $host_os in
aix*)
AS_CASE(["x/$CC"],
[x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
[#handle absolute path differently from PATH based program lookup
AS_CASE(["x$CC"],
[x/*],
[AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],
[AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
;;
esac
fi
fi
test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
AC_SUBST([PTHREAD_LIBS])
AC_SUBST([PTHREAD_CFLAGS])
AC_SUBST([PTHREAD_CC])
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$ax_pthread_ok" = xyes; then
ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])
:
else
ax_pthread_ok=no
$2
fi
AC_LANG_POP
])dnl AX_PTHREAD
libmongoc-1.9.2+dfsg/build/autotools/m4/pkg.m4 0000664 0000000 0000000 00000016231 13226174053 0021114 0 ustar 00root root 0000000 0000000 # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
# serial 1 (pkg-config-0.24)
#
# Copyright © 2004 Scott James Remnant .
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# PKG_PROG_PKG_CONFIG([MIN-VERSION])
# ----------------------------------
AC_DEFUN([PKG_PROG_PKG_CONFIG],
[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
fi
if test -n "$PKG_CONFIG"; then
_pkg_min_version=m4_default([$1], [0.9.0])
AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
PKG_CONFIG=""
fi
fi[]dnl
])# PKG_PROG_PKG_CONFIG
# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
#
# Check to see whether a particular set of modules exists. Similar
# to PKG_CHECK_MODULES(), but does not set variables or print errors.
#
# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
# only at the first occurence in configure.ac, so if the first place
# it's called might be skipped (such as if it is within an "if", you
# have to call PKG_CHECK_EXISTS manually
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_EXISTS],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
if test -n "$PKG_CONFIG" && \
AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
m4_default([$2], [:])
m4_ifvaln([$3], [else
$3])dnl
fi])
# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
# ---------------------------------------------
m4_define([_PKG_CONFIG],
[if test -n "$$1"; then
pkg_cv_[]$1="$$1"
elif test -n "$PKG_CONFIG"; then
PKG_CHECK_EXISTS([$3],
[pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
test "x$?" != "x0" && pkg_failed=yes ],
[pkg_failed=yes])
else
pkg_failed=untried
fi[]dnl
])# _PKG_CONFIG
# _PKG_SHORT_ERRORS_SUPPORTED
# -----------------------------
AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
else
_pkg_short_errors_supported=no
fi[]dnl
])# _PKG_SHORT_ERRORS_SUPPORTED
# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
# [ACTION-IF-NOT-FOUND])
#
#
# Note that if there is a possibility the first call to
# PKG_CHECK_MODULES might not happen, you should be sure to include an
# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
#
#
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_MODULES],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
pkg_failed=no
AC_MSG_CHECKING([for $1])
_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
_PKG_CONFIG([$1][_LIBS], [libs], [$2])
m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
and $1[]_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.])
if test $pkg_failed = yes; then
AC_MSG_RESULT([no])
_PKG_SHORT_ERRORS_SUPPORTED
if test $_pkg_short_errors_supported = yes; then
$1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
else
$1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
m4_default([$4], [AC_MSG_ERROR(
[Package requirements ($2) were not met:
$$1_PKG_ERRORS
Consider adjusting the PKG_CONFIG_PATH environment variable if you
installed software in a non-standard prefix.
_PKG_TEXT])[]dnl
])
elif test $pkg_failed = untried; then
AC_MSG_RESULT([no])
m4_default([$4], [AC_MSG_FAILURE(
[The pkg-config script could not be found or is too old. Make sure it
is in your PATH or set the PKG_CONFIG environment variable to the full
path to pkg-config.
_PKG_TEXT
To get pkg-config, see
dnl
dnl DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
dnl TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
dnl
dnl 0. You just DO WHAT THE FUCK YOU WANT TO.
dnl
dnl The above copyright notice and this permission notice shall be
dnl included in all copies or substantial portions of the Software.
dnl
dnl Simply put this file in your m4 macro directory (as everyone should be
dnl using AC_CONFIG_MACRO_DIR by now!) and add AS_AM_REALLY_SILENT somewhere
dnl in your configure.ac
AC_DEFUN([AS_AM_REALLY_SILENT],
[
AC_MSG_CHECKING([whether ${MAKE-make} can be made more silent])
dnl And we even cache that FFS!
AC_CACHE_VAL(
[as_cv_prog_make_can_be_really_silent],
[cat >confstfu.make <<\_WTF
SHELL = /bin/sh
all:
@echo '@@@%%%clutter rocks@@@%%%'
_WTF
as_cv_prog_make_can_be_really_silent=no
case `${MAKE-make} -f confstfu.make -s --no-print-directory 2>/dev/null` in
*'@@@%%%clutter rocks@@@%%%'*)
test $? = 0 && as_cv_prog_make_can_be_really_silent=yes
esac
rm -f confstfu.make])
if test $as_cv_prog_make_can_be_really_silent = yes; then
AC_MSG_RESULT([yes])
make_flags='`\
if test "x$(AM_DEFAULT_VERBOSITY)" = x0; then \
test -z "$V" -o "x$V" = x0 && echo -s; \
else \
test "x$V" = x0 && echo -s; \
fi`'
AC_SUBST([AM_MAKEFLAGS], [$make_flags])
else
AC_MSG_RESULT([no])
fi
])
libmongoc-1.9.2+dfsg/build/autotools/scripts/ 0000775 0000000 0000000 00000000000 13226174053 0021235 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/build/autotools/scripts/wrap-compiler-for-flag-check 0000775 0000000 0000000 00000000766 13226174053 0026523 0 ustar 00root root 0000000 0000000 #!/bin/sh
# There is no way to make clang's "argument unused" warning fatal. So when
# configure checks for supported flags, it runs $CC, $CXX, $LD via this
# wrapper.
#
# Ideally the search string would also include 'clang: ' but this output might
# depend on clang's argv[0].
if out=`"$@" 2>&1`; then
echo "$out"
if echo "$out" | grep 'warning: argument unused' >/dev/null; then
echo "$0: found clang warning"
exit 1
else
exit 0
fi
else
code=$?
echo "$out"
exit $code
fi
libmongoc-1.9.2+dfsg/build/cmake/ 0000775 0000000 0000000 00000000000 13226174053 0016575 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/build/cmake/.gitignore 0000664 0000000 0000000 00000000212 13226174053 0020560 0 ustar 00root root 0000000 0000000 libmongoc-1.0-config.cmake
libmongoc-1.0-config-version.cmake
libmongoc-static-1.0-config.cmake
libmongoc-static-1.0-config-version.cmake
libmongoc-1.9.2+dfsg/build/cmake/FindResSearch.cmake 0000664 0000000 0000000 00000003740 13226174053 0022263 0 ustar 00root root 0000000 0000000 include(CheckSymbolExists)
if (ENABLE_SRV STREQUAL ON OR ENABLE_SRV STREQUAL AUTO)
if (WIN32)
set (RESOLV_LIBS Dnsapi)
set (MONGOC_HAVE_DNSAPI 1)
set (MONGOC_HAVE_RES_NSEARCH 0)
set (MONGOC_HAVE_RES_NDESTROY 0)
set (MONGOC_HAVE_RES_NCLOSE 0)
set (MONGOC_HAVE_RES_SEARCH 0)
else ()
set (MONGOC_HAVE_DNSAPI 0)
# Thread-safe DNS query function for _mongoc_client_get_srv.
# Could be a macro, not a function, so use check_symbol_exists.
check_symbol_exists (res_nsearch resolv.h MONGOC_HAVE_RES_NSEARCH)
if (MONGOC_HAVE_RES_NSEARCH)
set (RESOLV_LIBS resolv)
set (MONGOC_HAVE_RES_SEARCH 0)
# We have res_nsearch. Call res_ndestroy (BSD/Mac) or res_nclose (Linux)?
check_symbol_exists (res_ndestroy resolv.h MONGOC_HAVE_RES_NDESTROY)
if (MONGOC_HAVE_RES_NDESTROY)
set (MONGOC_HAVE_RES_NCLOSE 0)
else ()
set (MONGOC_HAVE_RES_NDESTROY 0)
check_symbol_exists (res_nclose resolv.h MONGOC_HAVE_RES_NCLOSE)
if (NOT MONGOC_HAVE_RES_NCLOSE)
set (MONGOC_HAVE_RES_NCLOSE 0)
endif ()
endif ()
else ()
set (MONGOC_HAVE_RES_NSEARCH 0)
set (MONGOC_HAVE_RES_NDESTROY 0)
set (MONGOC_HAVE_RES_NCLOSE 0)
# Thread-unsafe function.
check_symbol_exists (res_search resolv.h MONGOC_HAVE_RES_SEARCH)
if (MONGOC_HAVE_RES_SEARCH)
set (RESOLV_LIBS resolv)
else ()
set (MONGOC_HAVE_RES_SEARCH 0)
endif()
endif ()
endif ()
else()
# ENABLE_SRV disabled, set default values for defines.
set (MONGOC_HAVE_DNSAPI 0)
set (MONGOC_HAVE_RES_NSEARCH 0)
set (MONGOC_HAVE_RES_NDESTROY 0)
set (MONGOC_HAVE_RES_NCLOSE 0)
set (MONGOC_HAVE_RES_SEARCH 0)
endif ()
if (ENABLE_SRV STREQUAL ON AND NOT RESOLV_LIBS)
message (
FATAL_ERROR
"Cannot find libresolv or dnsapi. Try setting ENABLE_SRV=OFF")
endif ()
libmongoc-1.9.2+dfsg/build/cmake/FindSASL2.cmake 0000664 0000000 0000000 00000002407 13226174053 0021227 0 ustar 00root root 0000000 0000000 include(CheckSymbolExists)
message (STATUS "Searching for sasl/sasl.h")
find_path (
SASL_INCLUDE_DIRS NAMES sasl/sasl.h
PATHS /include /usr/include /usr/local/include /usr/share/include /opt/include c:/sasl/include
DOC "Searching for sasl/sasl.h")
if (SASL_INCLUDE_DIRS)
message (STATUS " Found in ${SASL_INCLUDE_DIRS}")
else ()
message (STATUS " Not found (specify -DCMAKE_INCLUDE_PATH=C:/path/to/sasl/include for SASL support)")
endif ()
message (STATUS "Searching for libsasl2")
find_library(
SASL_LIBS NAMES sasl2
PATHS /usr/lib /lib /usr/local/lib /usr/share/lib /opt/lib /opt/share/lib /var/lib c:/sasl/lib
DOC "Searching for libsasl2")
if (SASL_LIBS)
message (STATUS " Found ${SASL_LIBS}")
else ()
message (STATUS " Not found (specify -DCMAKE_LIBRARY_PATH=C:/path/to/sasl/lib for SASL support)")
endif ()
if (SASL_INCLUDE_DIRS AND SASL_LIBS)
set (SASL_FOUND 1)
check_symbol_exists (
sasl_client_done
${SASL_INCLUDE_DIRS}/sasl/sasl.h
MONGOC_HAVE_SASL_CLIENT_DONE)
if (MONGOC_HAVE_SASL_CLIENT_DONE)
set (MONGOC_HAVE_SASL_CLIENT_DONE 1)
else ()
set (MONGOC_HAVE_SASL_CLIENT_DONE 0)
endif ()
else ()
set (SASL_FOUND 0)
set (MONGOC_HAVE_SASL_CLIENT_DONE 0)
endif ()
libmongoc-1.9.2+dfsg/build/cmake/FindSnappy.cmake 0000664 0000000 0000000 00000003571 13226174053 0021660 0 ustar 00root root 0000000 0000000 include(CheckSymbolExists)
if (NOT (ENABLE_SNAPPY STREQUAL SYSTEM
OR ENABLE_SNAPPY STREQUAL AUTO
OR ENABLE_SNAPPY STREQUAL OFF))
message (FATAL_ERROR
"ENABLE_SNAPPY option must be SYSTEM, AUTO, or OFF")
endif()
if (ENABLE_SNAPPY STREQUAL OFF)
set (SNAPPY_INCLUDE_DIRS)
set (SNAPPY_LIBS)
set (MONGOC_ENABLE_COMPRESSION_SNAPPY 0)
else ()
message (STATUS "Searching for compression library header snappy-c.h")
find_path (
SNAPPY_INCLUDE_DIRS NAMES snappy-c.h
PATHS /include /usr/include /usr/local/include /usr/share/include /opt/include c:/snappy/include
DOC "Searching for snappy-c.h")
if (NOT SNAPPY_INCLUDE_DIRS)
if (ENABLE_SNAPPY STREQUAL SYSTEM)
message (FATAL_ERROR " Not found (specify -DCMAKE_INCLUDE_PATH=C:/path/to/snappy/include for Snappy compression)")
else ()
message (STATUS " Not found (specify -DCMAKE_INCLUDE_PATH=C:/path/to/snappy/include for Snappy compression)")
endif ()
else ()
message (STATUS " Found in ${SNAPPY_INCLUDE_DIRS}")
message (STATUS "Searching for libsnappy")
find_library (
SNAPPY_LIBS NAMES snappy
PATHS /usr/lib /lib /usr/local/lib /usr/share/lib /opt/lib /opt/share/lib /var/lib c:/snappy/lib
DOC "Searching for libsnappy")
if (SNAPPY_LIBS)
message (STATUS " Found ${SNAPPY_LIBS}")
else ()
if (ENABLE_SNAPPY STREQUAL SYSTEM)
message (FATAL_ERROR " Not found (specify -DCMAKE_LIBRARY_PATH=C:/path/to/snappy/lib for Snappy compression)")
else ()
message (STATUS " Not found (specify -DCMAKE_LIBRARY_PATH=C:/path/to/snappy/lib for Snappy compression)")
endif ()
endif ()
endif ()
if (SNAPPY_INCLUDE_DIRS AND SNAPPY_LIBS)
set (MONGOC_ENABLE_COMPRESSION_SNAPPY 1)
else ()
set (MONGOC_ENABLE_COMPRESSION_SNAPPY 0)
endif ()
endif ()
libmongoc-1.9.2+dfsg/build/cmake/LoadVersion.cmake 0000664 0000000 0000000 00000002677 13226174053 0022040 0 ustar 00root root 0000000 0000000 function(LoadVersion FILEPATH PREFIX)
# E.g., "MONGOC_VERSION".
string(REPLACE ";" "" VERSION_NAME ${PREFIX} _VERSION)
file(STRINGS ${FILEPATH} VERSION_CONTENTS)
# A list of version components separated by dots and dashes: "1.3.0-dev"
string(REGEX MATCHALL "[^.-]+" VERSION ${VERSION_CONTENTS})
list(GET VERSION 0 MAJOR_VERSION)
string(REPLACE ";" "" MAJOR_VERSION_NAME ${PREFIX} _MAJOR_VERSION)
set(${MAJOR_VERSION_NAME} ${MAJOR_VERSION} PARENT_SCOPE)
list(GET VERSION 1 MINOR_VERSION)
string(REPLACE ";" "" MINOR_VERSION_NAME ${PREFIX} _MINOR_VERSION)
set(${MINOR_VERSION_NAME} ${MINOR_VERSION} PARENT_SCOPE)
list(GET VERSION 2 MICRO_VERSION)
string(REPLACE ";" "" MICRO_VERSION_NAME ${PREFIX} _MICRO_VERSION)
set(${MICRO_VERSION_NAME} ${MICRO_VERSION} PARENT_SCOPE)
string(REPLACE ";" "" PRERELEASE_VERSION_NAME ${PREFIX} _PRERELEASE_VERSION)
list(LENGTH VERSION VERSION_LENGTH)
if(VERSION_LENGTH GREATER 3)
list(GET VERSION 3 PRERELEASE_VERSION)
set(${PRERELEASE_VERSION_NAME} ${PRERELEASE_VERSION} PARENT_SCOPE)
set(${VERSION_NAME}
"${MAJOR_VERSION}.${MINOR_VERSION}.${MICRO_VERSION}-${PRERELEASE_VERSION}"
PARENT_SCOPE)
else()
set(${PRERELEASE_VERSION_NAME} "" PARENT_SCOPE)
set(${VERSION_NAME}
"${MAJOR_VERSION}.${MINOR_VERSION}.${MICRO_VERSION}"
PARENT_SCOPE)
endif()
endfunction(LoadVersion)
libmongoc-1.9.2+dfsg/build/cmake/MaintainerFlags.cmake 0000664 0000000 0000000 00000002033 13226174053 0022641 0 ustar 00root root 0000000 0000000 if (ENABLE_MAINTAINER_FLAGS AND NOT MSVC)
include(CheckCCompilerFlag)
message(STATUS "Detecting available maintainer flags")
file (READ "build/maintainer-flags.txt" MAINTAINER_FLAGS)
# Convert file contents into a CMake list (where each element in the list
# is one line of the file)
#
string (REGEX REPLACE ";" "\\\\;" MAINTAINER_FLAGS "${MAINTAINER_FLAGS}")
string (REGEX REPLACE "\n" ";" MAINTAINER_FLAGS "${MAINTAINER_FLAGS}")
foreach (MAINTAINER_FLAG ${MAINTAINER_FLAGS})
# Avoid useless "Performing Test FLAG_OK" message.
set (MESSAGES_ENABLED 0)
check_c_compiler_flag ("${MAINTAINER_FLAG}" FLAG_OK)
set (MESSAGES_ENABLED 1)
if (FLAG_OK)
message (STATUS "C compiler accepts ${MAINTAINER_FLAG}")
set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MAINTAINER_FLAG}")
else ()
message (STATUS "C compiler does not accept ${MAINTAINER_FLAG}")
endif ()
unset (FLAG_OK CACHE)
endforeach ()
message(STATUS "Maintainer flags: ${CMAKE_C_FLAGS}")
endif ()
libmongoc-1.9.2+dfsg/build/cmake/Makefile.am 0000664 0000000 0000000 00000000653 13226174053 0020635 0 ustar 00root root 0000000 0000000 EXTRA_DIST += \
build/cmake/FindResSearch.cmake \
build/cmake/FindSASL2.cmake \
build/cmake/FindSnappy.cmake \
build/cmake/MongoCPackage.cmake \
build/cmake/libmongoc-1.0-config.cmake.in \
build/cmake/libmongoc-1.0-config-version.cmake.in \
build/cmake/libmongoc-static-1.0-config.cmake.in \
build/cmake/libmongoc-static-1.0-config-version.cmake.in \
build/cmake/LoadVersion.cmake \
build/cmake/MaintainerFlags.cmake
libmongoc-1.9.2+dfsg/build/cmake/MongoCPackage.cmake 0000664 0000000 0000000 00000001712 13226174053 0022236 0 ustar 00root root 0000000 0000000 set (PACKAGE_INCLUDE_INSTALL_DIRS ${MONGOC_HEADER_INSTALL_DIR})
set (PACKAGE_LIBRARY_INSTALL_DIRS lib)
set (PACKAGE_LIBRARIES mongoc-1.0)
include (CMakePackageConfigHelpers)
# These aren't pkg-config files, they're CMake package configuration files.
function (install_package_config_file prefix)
foreach (suffix "config.cmake" "config-version.cmake")
configure_package_config_file (
build/cmake/libmongoc-${prefix}-${suffix}.in
${CMAKE_CURRENT_BINARY_DIR}/libmongoc-${prefix}-${suffix}
INSTALL_DESTINATION lib/cmake/libmongoc-${prefix}
PATH_VARS PACKAGE_INCLUDE_INSTALL_DIRS PACKAGE_LIBRARY_INSTALL_DIRS
)
install (
FILES
${CMAKE_CURRENT_BINARY_DIR}/libmongoc-${prefix}-${suffix}
DESTINATION
lib/cmake/libmongoc-${prefix}
)
endforeach ()
endfunction ()
install_package_config_file ("1.0")
if (ENABLE_STATIC)
install_package_config_file ("static-1.0")
endif ()
libmongoc-1.9.2+dfsg/build/cmake/libmongoc-1.0-config-version.cmake.in 0000664 0000000 0000000 00000002040 13226174053 0025373 0 ustar 00root root 0000000 0000000 # Copyright 2017 MongoDB Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set (PACKAGE_VERSION @MONGOC_VERSION@)
if ("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL "@MONGOC_MAJOR_VERSION@")
if ("${PACKAGE_FIND_VERSION_MINOR}" EQUAL "@MONGOC_MINOR_VERSION@")
set (PACKAGE_VERSION_EXACT TRUE)
elseif ("${PACKAGE_FIND_VERSION_MINOR}" LESS "@MONGOC_MINOR_VERSION@")
set (PACKAGE_VERSION_COMPATIBLE TRUE)
else ()
set (PACKAGE_VERSION_UNSUITABLE TRUE)
endif ()
elseif (PACKAGE_FIND_VERSION)
set (PACKAGE_VERSION_UNSUITABLE TRUE)
endif ()
libmongoc-1.9.2+dfsg/build/cmake/libmongoc-1.0-config.cmake.in 0000664 0000000 0000000 00000004701 13226174053 0023716 0 ustar 00root root 0000000 0000000 # Copyright 2017 MongoDB Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set (MONGOC_MAJOR_VERSION @MONGOC_MAJOR_VERSION@)
set (MONGOC_MINOR_VERSION @MONGOC_MINOR_VERSION@)
set (MONGOC_MICRO_VERSION @MONGOC_MICRO_VERSION@)
set (MONGOC_VERSION @MONGOC_VERSION@)
find_package (libbson-1.0 "@MONGOC_MAJOR_VERSION@.@MONGOC_MINOR_VERSION@" REQUIRED)
# In a pure-CMake project this is inserted by configure_package_config_file(),
# but we want to be able to build this file the same from the Autotools, so
# let's manually insert this code.
get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
macro(set_and_check _var _file)
set(${_var} "${_file}")
if(NOT EXISTS "${_file}")
message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
endif()
endmacro()
set_and_check (MONGOC_INCLUDE_DIRS "${PACKAGE_PREFIX_DIR}/include/libmongoc-1.0")
list (APPEND MONGOC_INCLUDE_DIRS ${BSON_INCLUDE_DIRS})
# We want to provide an absolute path to the library and we know the
# directory and the base name, but not the suffix, so we use CMake's
# find_library() to pick that up. Users can override this by configuring
# MONGOC_LIBRARY themselves.
find_library(MONGOC_LIBRARY mongoc-1.0 PATHS "${PACKAGE_PREFIX_DIR}/lib" NO_DEFAULT_PATH)
set (MONGOC_LIBRARIES ${MONGOC_LIBRARY} ${BSON_LIBRARIES})
# If this file is generated by the Autotools on Mac, SSL_LIBS might be
# "-framework CoreFoundation -framework Security". Split into a CMake array
# like "-framework CoreFoundation;-framework Security".
set (IS_FRAMEWORK_VAR 0)
foreach (LIB @SASL_LIBS@ @SSL_LIBS@ @SHM_LIB@ @RESOLV_LIBS@ @SNAPPY_LIBS@)
if (LIB STREQUAL "-framework")
set (IS_FRAMEWORK_VAR 1)
continue ()
elseif (IS_FRAMEWORK_VAR)
list (APPEND MONGOC_LIBRARIES "-framework ${LIB}")
set (IS_FRAMEWORK_VAR 0)
else ()
list (APPEND MONGOC_LIBRARIES ${LIB})
endif ()
endforeach ()
set (MONGOC_DEFINITIONS ${BSON_DEFINITIONS})
libmongoc-1.9.2+dfsg/build/cmake/libmongoc-static-1.0-config-version.cmake.in 0000664 0000000 0000000 00000002040 13226174053 0026660 0 ustar 00root root 0000000 0000000 # Copyright 2017 MongoDB Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set (PACKAGE_VERSION @MONGOC_VERSION@)
if ("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL "@MONGOC_MAJOR_VERSION@")
if ("${PACKAGE_FIND_VERSION_MINOR}" EQUAL "@MONGOC_MINOR_VERSION@")
set (PACKAGE_VERSION_EXACT TRUE)
elseif ("${PACKAGE_FIND_VERSION_MINOR}" LESS "@MONGOC_MINOR_VERSION@")
set (PACKAGE_VERSION_COMPATIBLE TRUE)
else ()
set (PACKAGE_VERSION_UNSUITABLE TRUE)
endif ()
elseif (PACKAGE_FIND_VERSION)
set (PACKAGE_VERSION_UNSUITABLE TRUE)
endif ()
libmongoc-1.9.2+dfsg/build/cmake/libmongoc-static-1.0-config.cmake.in 0000664 0000000 0000000 00000005323 13226174053 0025204 0 ustar 00root root 0000000 0000000 # Copyright 2017 MongoDB Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set (MONGOC_STATIC_MAJOR_VERSION @MONGOC_MAJOR_VERSION@)
set (MONGOC_STATIC_MINOR_VERSION @MONGOC_MINOR_VERSION@)
set (MONGOC_STATIC_MICRO_VERSION @MONGOC_MICRO_VERSION@)
set (MONGOC_STATIC_VERSION @MONGOC_VERSION@)
find_package (libbson-static-1.0 "@MONGOC_MAJOR_VERSION@.@MONGOC_MINOR_VERSION@" REQUIRED)
# In a pure-CMake project this is inserted by configure_package_config_file(),
# but we want to be able to build this file the same from the Autotools, so
# let's manually insert this code.
get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
macro(set_and_check _var _file)
set(${_var} "${_file}")
if(NOT EXISTS "${_file}")
message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
endif()
endmacro()
set_and_check (MONGOC_STATIC_INCLUDE_DIRS "${PACKAGE_PREFIX_DIR}/include/libmongoc-1.0")
list (APPEND MONGOC_STATIC_INCLUDE_DIRS ${BSON_STATIC_INCLUDE_DIRS})
# We want to provide an absolute path to the library and we know the
# directory and the base name, but not the suffix, so we use CMake's
# find_library() to pick that up. Users can override this by configuring
# MONGOC_STATIC_LIBRARY themselves.
find_library(MONGOC_STATIC_LIBRARY mongoc-static-1.0 PATHS "${PACKAGE_PREFIX_DIR}/lib" NO_DEFAULT_PATH)
if (MSVC)
set (MONGOC_STATIC_LIB_EXT "lib")
else ()
set (MONGOC_STATIC_LIB_EXT "a")
endif ()
set (MONGOC_STATIC_LIBRARIES ${MONGOC_STATIC_LIBRARY} ${ZLIB_STATIC_LIBRARY} ${BSON_STATIC_LIBRARIES})
# If this file is generated by the Autotools on Mac, SSL_LIBS might be
# "-framework CoreFoundation -framework Security". Split into a CMake array
# like "-framework CoreFoundation;-framework Security".
set (IS_FRAMEWORK_VAR 0)
foreach (LIB @SASL_LIBS@ @SSL_LIBS@ @SHM_LIB@ @ZLIB_LIBS@ @SNAPPY_LIBS@ @RESOLV_LIBS@)
if (LIB STREQUAL "-framework")
set (IS_FRAMEWORK_VAR 1)
continue ()
elseif (IS_FRAMEWORK_VAR)
list (APPEND MONGOC_STATIC_LIBRARIES "-framework ${LIB}")
set (IS_FRAMEWORK_VAR 0)
else ()
list (APPEND MONGOC_STATIC_LIBRARIES ${LIB})
endif ()
endforeach ()
set (MONGOC_STATIC_DEFINITIONS MONGOC_STATIC ${BSON_STATIC_DEFINITIONS})
libmongoc-1.9.2+dfsg/build/future_function_templates/ 0000775 0000000 0000000 00000000000 13226174053 0023012 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/build/future_function_templates/future-functions.c.template 0000664 0000000 0000000 00000003542 13226174053 0030314 0 ustar 00root root 0000000 0000000 {{ header_comment }}
/*
* Define two sets of functions: background functions and future functions.
* A background function like background_mongoc_cursor_next runs a driver
* operation on a thread.
* A future function like future_mongoc_cursor_next launches the background
* operation and returns a future_t that will resolve when the operation
* finishes.
*
* These are used with mock_server_t so you can run the driver on a thread while
* controlling the server from the main thread.
*/
#include "mongoc-topology-private.h"
#include "future-functions.h"
{% for F in future_functions %}
static void *
background_{{ F.name }} (void *data)
{
future_t *future = (future_t *) data;
future_value_t return_value;
return_value.type = future_value_{{ F.ret_type }}_type;
{% if F.ret_type == 'void' %}
{{ F.name }} ({% for P in F.params %}
future_value_get_{{ P.type_name }} (future_get_param (future, {{ loop.index0 }})){% if not loop.last %},{% endif %}{% endfor %});
{% else %}
future_value_set_{{ F.ret_type }} (
&return_value,
{{ F.name }} ({% for P in F.params %}
future_value_get_{{ P.type_name }} (future_get_param (future, {{ loop.index0 }})){% if not loop.last %},{% endif %}{% endfor %}
));
{% endif %}
future_resolve (future, return_value);
return NULL;
}
{% endfor %}
{% for F in future_functions %}
future_t *
{{ F|future_function_name }} ({% for P in F.params %}
{{ P.type_name }} {{ P.name }}{% if not loop.last %},{% endif %}{% endfor %})
{
future_t *future = future_new (future_value_{{ F.ret_type }}_type,
{{ F.params | length }});
{% for P in F.params %}
future_value_set_{{ P.type_name }} (
future_get_param (future, {{ loop.index0 }}), {{ P.name }});
{% endfor %}
future_start (future, background_{{ F.name }});
return future;
}
{% endfor %}
libmongoc-1.9.2+dfsg/build/future_function_templates/future-functions.h.template 0000664 0000000 0000000 00000000603 13226174053 0030314 0 ustar 00root root 0000000 0000000 #ifndef FUTURE_FUNCTIONS_H
#define FUTURE_FUNCTIONS_H
#include "future-value.h"
#include "future.h"
#include "mongoc-bulk-operation.h"
{{ header_comment }}
{% for F in future_functions %}
future_t *
{{ F|future_function_name }} (
{% for P in F.params %}
{{ P.type_name }} {{ P.name }}{% if not loop.last %},{% endif %}{% endfor %}
);
{% endfor %}
#endif /* FUTURE_FUNCTIONS_H */
libmongoc-1.9.2+dfsg/build/future_function_templates/future-value.c.template 0000664 0000000 0000000 00000001414 13226174053 0027414 0 ustar 00root root 0000000 0000000 #include "future-value.h"
{{ header_comment }}
future_value_t *
future_value_new ()
{
return (future_value_t *) bson_malloc0 (sizeof (future_value_t));
}
void
future_value_set_void (future_value_t *future_value)
{
future_value->type = future_value_void_type;
}
void
future_value_get_void (future_value_t *future_value)
{
BSON_ASSERT (future_value->type == future_value_void_type);
}
{% for T in type_list %}
void
future_value_set_{{ T }} (future_value_t *future_value, {{ T }} value)
{
future_value->type = future_value_{{ T }}_type;
future_value->{{ T }}_value = value;
}
{{ T }}
future_value_get_{{ T }} (future_value_t *future_value)
{
BSON_ASSERT (future_value->type == future_value_{{ T }}_type);
return future_value->{{ T }}_value;
}
{% endfor %}
libmongoc-1.9.2+dfsg/build/future_function_templates/future-value.h.template 0000664 0000000 0000000 00000002242 13226174053 0027421 0 ustar 00root root 0000000 0000000 #ifndef FUTURE_VALUE_H
#define FUTURE_VALUE_H
#include
#include
#include "mongoc-server-description.h"
#include "mongoc-cluster-private.h"
#include "mongoc-topology-private.h"
{{ header_comment }}
{% for T in typedef_list %}{% if T.typedef %}
typedef {{ T.typedef }} {{ T.name }};{% endif %}{% endfor %}
typedef enum {
future_value_no_type = 0,
{% for T in type_list_with_void %} future_value_{{ T }}_type,
{% endfor %}
} future_value_type_t;
typedef struct _future_value_t
{
future_value_type_t type;
union {
{% for T in type_list %} {{ T }} {{ T }}_value;
{% endfor %}
} value;
} future_value_t;
future_value_t *future_value_new ();
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
#endif
void future_value_set_void (future_value_t *future_value);
void future_value_get_void (future_value_t *future_value);
{% for T in type_list %}
void
future_value_set_{{ T }}(
future_value_t *future_value,
{{ T }} value);
{{ T }}
future_value_get_{{ T }} (
future_value_t *future_value);
{% endfor %}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif /* FUTURE_VALUE_H */
libmongoc-1.9.2+dfsg/build/future_function_templates/future.c.template 0000664 0000000 0000000 00000005255 13226174053 0026311 0 ustar 00root root 0000000 0000000 #include
#include "mongoc-array-private.h"
#include "mongoc-thread-private.h"
#include "future.h"
#include "../test-libmongoc.h"
{{ header_comment }}
void
future_get_void (future_t *future)
{
if (!future_wait (future)) {
fprintf (stderr, "%s timed out\n", BSON_FUNC);
fflush (stderr);
abort ();
}
}
{% for T in type_list %}
{{ T }}
future_get_{{ T }} (future_t *future)
{
if (future_wait (future)) {
return future_value_get_{{ T }} (&future->return_value);
}
fprintf (stderr, "%s timed out\n", BSON_FUNC);
fflush (stderr);
abort ();
}
{% endfor %}
future_t *
future_new (future_value_type_t return_type, int argc)
{
future_t *future;
future = (future_t *)bson_malloc0 (sizeof *future);
future->return_value.type = return_type;
future->argc = argc;
future->argv = (future_value_t *)bson_malloc0 ((size_t) argc * sizeof(future_value_t));
mongoc_cond_init (&future->cond);
mongoc_mutex_init (&future->mutex);
return future;
}
future_value_t *
future_get_param (future_t *future, int i)
{
return &future->argv[i];
}
void
future_start (future_t *future,
void *(*start_routine)(void *))
{
int r = mongoc_thread_create (&future->thread,
start_routine,
(void *) future);
BSON_ASSERT (!r);
}
void
future_resolve (future_t *future, future_value_t return_value)
{
mongoc_mutex_lock (&future->mutex);
BSON_ASSERT (!future->resolved);
BSON_ASSERT (future->return_value.type == return_value.type);
future->return_value = return_value;
future->resolved = true;
mongoc_cond_signal (&future->cond);
mongoc_mutex_unlock (&future->mutex);
}
bool
future_wait_max (future_t *future, int64_t timeout_ms)
{
int64_t remaining_usec = timeout_ms * 1000;
int64_t deadline = bson_get_monotonic_time () + timeout_ms * 1000;
bool resolved;
mongoc_mutex_lock (&future->mutex);
while (!future->resolved && remaining_usec > 0) {
mongoc_cond_timedwait (&future->cond, &future->mutex,
remaining_usec / 1000);
remaining_usec = deadline - bson_get_monotonic_time ();
}
resolved = future->resolved;
mongoc_mutex_unlock (&future->mutex);
if (resolved) {
future->awaited = true;
/* free memory */
mongoc_thread_join (future->thread);
}
return resolved;
}
bool
future_wait (future_t *future)
{
return future_wait_max (future, get_future_timeout_ms ());
}
void
future_destroy (future_t *future)
{
BSON_ASSERT (future->awaited);
bson_free (future->argv);
mongoc_cond_destroy (&future->cond);
mongoc_mutex_destroy (&future->mutex);
bson_free (future);
}
libmongoc-1.9.2+dfsg/build/future_function_templates/future.h.template 0000664 0000000 0000000 00000001715 13226174053 0026313 0 ustar 00root root 0000000 0000000 #ifndef FUTURE_H
#define FUTURE_H
#include
#include "future-value.h"
#include "mongoc-thread-private.h"
{{ header_comment }}
typedef struct
{
bool resolved;
bool awaited;
future_value_t return_value;
int argc;
future_value_t *argv;
mongoc_cond_t cond;
mongoc_mutex_t mutex;
mongoc_thread_t thread;
} future_t;
future_t *future_new (future_value_type_t return_type, int argc);
future_value_t *future_get_param (future_t *future, int i);
void future_start (future_t *future,
void *(*start_routine)(void *));
void future_resolve (future_t *future, future_value_t return_value);
bool future_wait (future_t *future);
bool future_wait_max (future_t *future, int64_t timeout_ms);
void future_get_void (future_t *future);
{% for T in type_list %}
{{ T }}
future_get_{{ T }} (future_t *future);
{% endfor %}
void future_destroy (future_t *future);
#endif /* FUTURE_H */
libmongoc-1.9.2+dfsg/build/generate-future-functions.py 0000664 0000000 0000000 00000044324 13226174053 0023206 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
#
# Copyright 2015 MongoDB, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Generate test functions for use with mock_server_t.
Defines functions like future_cursor_next in future-functions.h and
future-functions.c, which defer a libmongoc operation to a background thread
via functions like background_cursor_next. Also defines functions like
future_value_set_bson_ptr and future_value_get_bson_ptr which support the
future / background functions, and functions like future_get_bson_ptr which
wait for a future to resolve, then return its value.
These future functions are used in conjunction with mock_server_t to
conveniently test libmongoc wire protocol operations.
Written for Python 2.6+, requires Jinja 2 for templating.
"""
from collections import namedtuple
from os.path import basename, dirname, join as joinpath, normpath
from jinja2 import Environment, FileSystemLoader # Please "pip install jinja2".
this_dir = dirname(__file__)
template_dir = joinpath(this_dir, 'future_function_templates')
mock_server_dir = normpath(joinpath(this_dir, '../tests/mock_server'))
# Add additional types here. Use typedefs for derived types so they can
# be named with one symbol.
typedef = namedtuple("typedef", ["name", "typedef"])
# These are typedef'ed if necessary in future-value.h, and added to the union
# of possible future_value_t.value types. future_value_t getters and setters
# are generated for all types, as well as future_t getters.
typedef_list = [
# Fundamental.
typedef("bool", None),
typedef("char_ptr", "char *"),
typedef("char_ptr_ptr", "char **"),
typedef("int", None),
typedef("int64_t", None),
typedef("size_t", None),
typedef("ssize_t", None),
typedef("uint32_t", None),
# Const fundamental.
typedef("const_char_ptr", "const char *"),
# libbson.
typedef("bson_error_ptr", "bson_error_t *"),
typedef("bson_ptr", "bson_t *"),
# Const libbson.
typedef("const_bson_ptr", "const bson_t *"),
typedef("const_bson_ptr_ptr", "const bson_t **"),
# libmongoc.
typedef("mongoc_bulk_operation_ptr", "mongoc_bulk_operation_t *"),
typedef("mongoc_client_ptr", "mongoc_client_t *"),
typedef("mongoc_client_pool_ptr", "mongoc_client_pool_t *"),
typedef("mongoc_collection_ptr", "mongoc_collection_t *"),
typedef("mongoc_cluster_ptr", "mongoc_cluster_t *"),
typedef("mongoc_cmd_parts_ptr", "mongoc_cmd_parts_t *"),
typedef("mongoc_cursor_ptr", "mongoc_cursor_t *"),
typedef("mongoc_database_ptr", "mongoc_database_t *"),
typedef("mongoc_gridfs_file_ptr", "mongoc_gridfs_file_t *"),
typedef("mongoc_gridfs_ptr", "mongoc_gridfs_t *"),
typedef("mongoc_insert_flags_t", None),
typedef("mongoc_iovec_ptr", "mongoc_iovec_t *"),
typedef("mongoc_server_stream_ptr", "mongoc_server_stream_t *"),
typedef("mongoc_query_flags_t", None),
typedef("const_mongoc_index_opt_t", "const mongoc_index_opt_t *"),
typedef("mongoc_server_description_ptr", "mongoc_server_description_t *"),
typedef("mongoc_ss_optype_t", None),
typedef("mongoc_topology_ptr", "mongoc_topology_t *"),
typedef("mongoc_write_concern_ptr", "mongoc_write_concern_t *"),
typedef("mongoc_change_stream_ptr", "mongoc_change_stream_t *"),
# Const libmongoc.
typedef("const_mongoc_find_and_modify_opts_ptr", "const mongoc_find_and_modify_opts_t *"),
typedef("const_mongoc_iovec_ptr", "const mongoc_iovec_t *"),
typedef("const_mongoc_read_prefs_ptr", "const mongoc_read_prefs_t *"),
typedef("const_mongoc_write_concern_ptr", "const mongoc_write_concern_t *"),
]
type_list = [T.name for T in typedef_list]
type_list_with_void = type_list + ['void']
param = namedtuple("param", ["type_name", "name"])
future_function = namedtuple("future_function", ["ret_type", "name", "params"])
# Add additional functions to be tested here. For a name like "cursor_next", we
# generate two functions: future_cursor_next to prepare the future_t and launch
# a background thread, and background_cursor_next to run on the thread and
# resolve the future.
future_functions = [
future_function("uint32_t",
"mongoc_bulk_operation_execute",
[param("mongoc_bulk_operation_ptr", "bulk"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_client_command_simple",
[param("mongoc_client_ptr", "client"),
param("const_char_ptr", "db_name"),
param("const_bson_ptr", "command"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_client_command_with_opts",
[param("mongoc_client_ptr", "client"),
param("const_char_ptr", "db_name"),
param("const_bson_ptr", "command"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("const_bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_client_read_command_with_opts",
[param("mongoc_client_ptr", "client"),
param("const_char_ptr", "db_name"),
param("const_bson_ptr", "command"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("const_bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_client_write_command_with_opts",
[param("mongoc_client_ptr", "client"),
param("const_char_ptr", "db_name"),
param("const_bson_ptr", "command"),
param("const_bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_client_read_write_command_with_opts",
[param("mongoc_client_ptr", "client"),
param("const_char_ptr", "db_name"),
param("const_bson_ptr", "command"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("const_bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("void",
"mongoc_client_kill_cursor",
[param("mongoc_client_ptr", "client"),
param("int64_t", "cursor_id")]),
future_function("mongoc_cursor_ptr",
"mongoc_collection_aggregate",
[param("mongoc_collection_ptr", "collection"),
param("mongoc_query_flags_t", "flags"),
param("const_bson_ptr", "pipeline"),
param("const_bson_ptr", "options"),
param("const_mongoc_read_prefs_ptr", "read_prefs")]),
future_function("int64_t",
"mongoc_collection_count",
[param("mongoc_collection_ptr", "collection"),
param("mongoc_query_flags_t", "flags"),
param("const_bson_ptr", "query"),
param("int64_t", "skip"),
param("int64_t", "limit"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("bson_error_ptr", "error")]),
future_function("int64_t",
"mongoc_collection_count_with_opts",
[param("mongoc_collection_ptr", "collection"),
param("mongoc_query_flags_t", "flags"),
param("const_bson_ptr", "query"),
param("int64_t", "skip"),
param("int64_t", "limit"),
param("const_bson_ptr", "opts"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_collection_create_index_with_opts",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "keys"),
param("const_mongoc_index_opt_t", "opt"),
param("bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_collection_find_and_modify_with_opts",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "query"),
param("const_mongoc_find_and_modify_opts_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_collection_find_and_modify",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "query"),
param("const_bson_ptr", "sort"),
param("const_bson_ptr", "update"),
param("const_bson_ptr", "fields"),
param("bool", "_remove"),
param("bool", "upsert"),
param("bool", "_new"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("mongoc_cursor_ptr",
"mongoc_collection_find_indexes_with_opts",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "opts")]),
future_function("bool",
"mongoc_collection_stats",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "options"),
param("bson_ptr", "stats"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_collection_insert_one",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "document"),
param("const_bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_collection_read_write_command_with_opts",
[param("mongoc_collection_ptr", "collection"),
param("const_bson_ptr", "command"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("const_bson_ptr", "opts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_collection_insert_bulk",
[param("mongoc_collection_ptr", "collection"),
param("mongoc_insert_flags_t", "flags"),
param("const_bson_ptr_ptr", "documents"),
param("uint32_t", "n_documents"),
param("const_mongoc_write_concern_ptr", "write_concern"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_cluster_run_command_parts",
[param("mongoc_cluster_ptr", "cluster"),
param("mongoc_server_stream_ptr", "server_stream"),
param("mongoc_cmd_parts_ptr", "parts"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("void",
"mongoc_cursor_destroy",
[param("mongoc_cursor_ptr", "cursor")]),
future_function("bool",
"mongoc_cursor_next",
[param("mongoc_cursor_ptr", "cursor"),
param("const_bson_ptr_ptr", "doc")]),
future_function("char_ptr_ptr",
"mongoc_client_get_database_names_with_opts",
[param("mongoc_client_ptr", "client"),
param("const_bson_ptr", "opts"),
param("bson_error_ptr", "error")]),
future_function("mongoc_server_description_ptr",
"mongoc_client_select_server",
[param("mongoc_client_ptr", "client"),
param("bool", "for_writes"),
param("const_mongoc_read_prefs_ptr", "prefs"),
param("bson_error_ptr", "error")]),
future_function("void",
"mongoc_client_destroy",
[param("mongoc_client_ptr", "client")]),
future_function("void",
"mongoc_client_pool_destroy",
[param("mongoc_client_pool_ptr", "pool")]),
future_function("bool",
"mongoc_database_command_simple",
[param("mongoc_database_ptr", "database"),
param("bson_ptr", "command"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("bson_ptr", "reply"),
param("bson_error_ptr", "error")]),
future_function("char_ptr_ptr",
"mongoc_database_get_collection_names_with_opts",
[param("mongoc_database_ptr", "database"),
param("const_bson_ptr", "opts"),
param("bson_error_ptr", "error")]),
future_function("ssize_t",
"mongoc_gridfs_file_readv",
[param("mongoc_gridfs_file_ptr", "file"),
param("mongoc_iovec_ptr", "iov"),
param("size_t", "iovcnt"),
param("size_t", "min_bytes"),
param("uint32_t", "timeout_msec")]),
future_function("mongoc_gridfs_file_ptr",
"mongoc_gridfs_find_one",
[param("mongoc_gridfs_ptr", "gridfs"),
param("const_bson_ptr", "query"),
param("bson_error_ptr", "error")]),
future_function("bool",
"mongoc_gridfs_file_remove",
[param("mongoc_gridfs_file_ptr", "file"),
param("bson_error_ptr", "error")]),
future_function("int",
"mongoc_gridfs_file_seek",
[param("mongoc_gridfs_file_ptr", "file"),
param("int64_t", "delta"),
param("int", "whence")]),
future_function("ssize_t",
"mongoc_gridfs_file_writev",
[param("mongoc_gridfs_file_ptr", "file"),
param("const_mongoc_iovec_ptr", "iov"),
param("size_t", "iovcnt"),
param("uint32_t", "timeout_msec")]),
future_function("mongoc_gridfs_file_ptr",
"mongoc_gridfs_find_one_with_opts",
[param("mongoc_gridfs_ptr", "gridfs"),
param("const_bson_ptr", "filter"),
param("const_bson_ptr", "opts"),
param("bson_error_ptr", "error")]),
future_function("mongoc_server_description_ptr",
"mongoc_topology_select",
[param("mongoc_topology_ptr", "topology"),
param("mongoc_ss_optype_t", "optype"),
param("const_mongoc_read_prefs_ptr", "read_prefs"),
param("bson_error_ptr", "error")]),
future_function("mongoc_gridfs_ptr",
"mongoc_client_get_gridfs",
[param("mongoc_client_ptr", "client"),
param("const_char_ptr", "db"),
param("const_char_ptr", "prefix"),
param("bson_error_ptr", "error")]),
future_function("mongoc_change_stream_ptr",
"mongoc_collection_watch",
[param("mongoc_collection_ptr", "coll"),
param("const_bson_ptr", "pipeline"),
param("const_bson_ptr", "opts")]),
future_function("bool",
"mongoc_change_stream_next",
[param("mongoc_change_stream_ptr", "stream"),
param("const_bson_ptr_ptr", "bson")]),
future_function("void",
"mongoc_change_stream_destroy",
[param("mongoc_change_stream_ptr", "stream")]),
]
for fn in future_functions:
if fn.ret_type not in type_list_with_void:
raise Exception('bad type "%s"\n\nin %s' % (fn.ret_type, fn))
for p in fn.params:
if p.type_name not in type_list:
raise Exception('bad type "%s"\n\nin %s' % (p.type_name, fn))
header_comment = """/**************************************************
*
* Generated by build/%s.
*
* DO NOT EDIT THIS FILE.
*
*************************************************/
/* clang-format off */""" % basename(__file__)
def future_function_name(fn):
if fn.name.startswith('mongoc'):
# E.g. future_cursor_next().
return 'future' + fn.name[len('mongoc'):]
else:
# E.g. future__mongoc_client_kill_cursor().
return 'future_' + fn.name
env = Environment(loader=FileSystemLoader(template_dir))
env.filters['future_function_name'] = future_function_name
files = ["future.h",
"future.c",
"future-value.h",
"future-value.c",
"future-functions.h",
"future-functions.c"]
for file_name in files:
print(file_name)
with open(joinpath(mock_server_dir, file_name), 'w+') as f:
t = env.get_template(file_name + ".template")
f.write(t.render(globals()))
f.write('\n')
libmongoc-1.9.2+dfsg/build/maintainer-flags.txt 0000664 0000000 0000000 00000000476 13226174053 0021506 0 ustar 00root root 0000000 0000000 -Wall
-Waggregate-return
-Wdeclaration-after-statement
-Wempty-body
-Wformat
-Wformat-nonliteral
-Wformat-security
-Winit-self
-Winline
-Wmissing-include-dirs
-Wno-strict-aliasing
-Wno-uninitialized
-Wredundant-decls
-Wreturn-type
-Wshadow
-Wswitch-default
-Wswitch-enum
-Wundef
-Wuninitialized
-Wexpansion-to-defined
libmongoc-1.9.2+dfsg/configure.ac 0000664 0000000 0000000 00000006331 13226174053 0016707 0 ustar 00root root 0000000 0000000 AC_PREREQ(2.60)
# Set version from contents of "VERSION_CURRENT" file (and strip newlines).
AC_INIT([mongo-c-driver],
m4_esyscmd(cat VERSION_CURRENT | tr -d '\n'),
[https://jira.mongodb.org/browse/CDRIVER])
m4_include([build/autotools/Versions.m4])
AC_CONFIG_MACRO_DIR([build/autotools/m4])
AC_CONFIG_AUX_DIR([build/autotools])
AC_SUBST(ACLOCAL_AMFLAGS, "-I build/autotools")
MONGOC_API_VERSION=1.0
AC_SUBST(MONGOC_API_VERSION)
# AS_VAR_COPY is available in AC 2.64 and on, but we only require 2.60.
# If we're on an older version, we define it ourselves:
m4_ifndef([AS_VAR_COPY],
[m4_define([AS_VAR_COPY],
[AS_LITERAL_IF([$1[]$2], [$1=$$2], [eval $1=\$$2])])])
# Get "user-set cflags" here, before we've added the flags we use by default
AS_VAR_COPY(MONGOC_USER_SET_CFLAGS, [CFLAGS])
AC_SUBST(MONGOC_USER_SET_CFLAGS)
AS_VAR_COPY(MONGOC_USER_SET_LDFLAGS, [LDFLAGS])
AC_SUBST(MONGOC_USER_SET_LDFLAGS)
m4_include([build/autotools/CheckCompiler.m4])
m4_include([build/autotools/CheckProgs.m4])
m4_include([build/autotools/CheckHost.m4])
m4_include([build/autotools/CheckTarget.m4])
m4_include([build/autotools/SetupLibtool.m4])
LT_INIT
m4_include([build/autotools/ReadCommandLineArguments.m4])
m4_include([build/autotools/CheckSasl.m4])
#if test "x$MONGOC_36_EXPERIMENT" = "xyes"; then
# m4_include([build/autotools/feature.m4])
#else
# AC_SUBST(MONGOC_FEATURE, 0)
# enable_feature_1=no
#fi
m4_include([build/autotools/CheckSnappy.m4])
m4_include([build/autotools/CheckZlib.m4])
if test "x$with_zlib" != "xno" -o "x$with_snappy" != "xno"; then
AC_SUBST(MONGOC_ENABLE_COMPRESSION, 1)
else
AC_SUBST(MONGOC_ENABLE_COMPRESSION, 0)
fi
m4_include([build/autotools/CheckSSL.m4])
m4_include([build/autotools/FindDependencies.m4])
m4_include([build/autotools/FindResSearch.m4])
m4_include([build/autotools/MaintainerFlags.m4])
m4_include([build/autotools/PlatformFlags.m4])
m4_include([build/autotools/Optimizations.m4])
m4_include([build/autotools/Coverage.m4])
m4_include([build/autotools/WeakSymbols.m4])
m4_include([build/autotools/AutomaticInitAndCleanup.m4])
AS_VAR_COPY(MONGOC_CC, [CC])
AC_SUBST(MONGOC_CC)
# We would put AM_INIT_AUTOMAKE into SetupAutomake.m4, but seems to cause
# autoconf errors.
AM_INIT_AUTOMAKE([foreign subdir-objects tar-ustar])
m4_include([build/autotools/SetupAutomake.m4])
# Substitute our dependencies into the pkg-config and CMake config files.
MONGOC_LIBS="${SASL_LIBS} ${SSL_LIBS} ${SHM_LIB} ${RESOLV_LIBS}"
if test "x$with_zlib" = "xbundled"; then
AC_SUBST(MONGOC_ZLIB_BUNDLED, 1)
else
MONGOC_LIBS="${MONGOC_LIBS} ${ZLIB_LIBS}"
fi
if test "x$with_snappy" = "xno"; then
AC_SUBST(MONGOC_SNAPPY_BUNDLED, 1)
else
MONGOC_LIBS="${MONGOC_LIBS} ${SNAPPY_LIBS}"
fi
AC_SUBST(MONGOC_LIBS)
AC_CONFIG_FILES([
Makefile
src/libmongoc-1.0.pc
src/libmongoc-static-1.0.pc
src/libmongoc-ssl-1.0.pc
build/cmake/libmongoc-1.0-config-version.cmake
build/cmake/libmongoc-static-1.0-config.cmake
build/cmake/libmongoc-1.0-config.cmake
build/cmake/libmongoc-static-1.0-config-version.cmake
src/mongoc/mongoc-config.h
src/mongoc/mongoc-version.h
src/zlib-1.2.11/zconf.h
])
m4_include([build/autotools/Libbson.m4])
m4_include([build/autotools/PrintBuildConfiguration.m4])
libmongoc-1.9.2+dfsg/doc/ 0000775 0000000 0000000 00000000000 13226174053 0015163 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/.gitignore 0000664 0000000 0000000 00000000235 13226174053 0017153 0 ustar 00root root 0000000 0000000 *.7
*.pyc
.doctrees
objects.inv
html/*.html
html/*.css
html/*.js
html/*.png
html/_sources
html/_static
html/.buildinfo
html/.nojekyll
man/*.3
man/.buildinfo
libmongoc-1.9.2+dfsg/doc/Makefile.am 0000664 0000000 0000000 00000000604 13226174053 0017217 0 ustar 00root root 0000000 0000000 EXTRA_DIST += $(wildcard doc/*.rst)
EXTRA_DIST += \
doc/conf.py \
doc/mongoc/__init__.py \
doc/mongoc-theme/globaltoc.html \
doc/mongoc-theme/layout.html \
doc/mongoc-theme/static/mongoc.css_t \
doc/mongoc-theme/static/pygments.css \
doc/mongoc-theme/theme.conf \
doc/taglist.py \
doc/libbson-objects.inv \
$(wildcard doc/includes/*.txt) \
$(wildcard doc/static/*)
libmongoc-1.9.2+dfsg/doc/advanced-connections.rst 0000664 0000000 0000000 00000016514 13226174053 0022011 0 ustar 00root root 0000000 0000000 :man_page: mongoc_advanced_connections
Advanced Connections
====================
The following guide contains information specific to certain types of MongoDB configurations.
For an example of connecting to a simple standalone server, see the :ref:`Tutorial `. To establish a connection with authentication options enabled, see the :doc:`Authentication ` page.
Connecting to a Replica Set
---------------------------
Connecting to a `replica set
#include
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_init ();
/* Create our MongoDB Client */
client = mongoc_client_new (
"mongodb://host01:27017,host02:27017,host03:27017/?replicaSet=myreplset");
/* Do some work */
/* TODO */
/* Clean up */
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
.. tip::
Multiple hostnames can be specified in the MongoDB connection string URI, with a comma separating hosts in the seed list.
It is recommended to use a seed list of members of the replica set to allow the driver to connect to any node.
Connecting to a Sharded Cluster
-------------------------------
To connect to a `sharded cluster
#include
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_init ();
/* Create our MongoDB Client */
client = mongoc_client_new ("mongodb://myshard01:27017/");
/* Do something with client ... */
/* Free the client */
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
Connecting to an IPv6 Address
-----------------------------
The MongoDB C Driver will automatically resolve IPv6 addresses from host names. However, to specify an IPv6 address directly, wrap the address in ``[]``.
.. code-block:: none
mongoc_uri_t *uri = mongoc_uri_new ("mongodb://[::1]:27017");
Connecting to a UNIX Domain Socket
----------------------------------
On UNIX-like systems, the C Driver can connect directly to a MongoDB server using a UNIX domain socket. Pass the URL-encoded path to the socket, which *must* be suffixed with ``.sock``. For example, to connect to a domain socket at ``/tmp/mongodb-27017.sock``:
.. code-block:: none
mongoc_uri_t *uri = mongoc_uri_new ("mongodb://%2Ftmp%2Fmongodb-27017.sock");
Include username and password like so:
.. code-block:: none
mongoc_uri_t *uri = mongoc_uri_new ("mongodb://user:pass@%2Ftmp%2Fmongodb-27017.sock");
Connecting to a server over SSL
-------------------------------
These are instructions for configuring TLS/SSL connections.
To run a server locally (on port 27017, for example):
.. code-block:: none
$ mongod --port 27017 --sslMode requireSSL --sslPEMKeyFile server.pem --sslCAFile ca.pem
Add ``/?ssl=true`` to the end of a client URI.
.. code-block:: none
mongoc_client_t *client = NULL;
client = mongoc_client_new ("mongodb://localhost:27017/?ssl=true");
MongoDB requires client certificates by default, unless the ``--sslAllowConnectionsWithoutCertificates`` is provided. The C Driver can be configured to present a client certificate using a ``mongoc_ssl_opt_t``:
.. code-block:: none
const mongoc_ssl_opt_t *ssl_default = mongoc_ssl_opt_get_default ();
mongoc_ssl_opt_t ssl_opts = { 0 };
/* optionally copy in a custom trust directory or file; otherwise the default is used. */
memcpy (&ssl_opts, ssl_default, sizeof ssl_opts);
ssl_opts.pem_file = "client.pem"
mongoc_client_set_ssl_opts (client, &ssl_opts);
The client certificate provided by ``pem_file`` must be issued by one of the server trusted Certificate Authorities listed in ``--sslCAFile``, or issued by a CA in the native certificate store on the server when omitted.
To verify the server certificate against a specific CA, provide a PEM armored file with a CA certificate, or concatenated list of CA certificates using the ``ca_file`` option, or ``c_rehash`` directory structure of CAs, pointed to using the ``ca_dir`` option. When no ``ca_file`` or ``ca_dir`` is provided, the driver will use CAs provided by the native platform certificate store.
See :doc:`mongoc_ssl_opt_t` for more information on the various SSL related options.
Compressing data to and from MongoDB
------------------------------------
MongoDB 3.4 added Snappy compression support, and zlib compression in 3.6.
To enable compression support the client must be configured with which compressors to use:
.. code-block:: none
mongoc_client_t *client = NULL;
client = mongoc_client_new ("mongodb://localhost:27017/?compressors=snappy,zlib");
The ``compressors`` option specifies the priority order of compressors the
client wants to use. Messages are compressed if the client and server share any
compressors in common.
Note that the compressor used by the server might not be the same compressor as
the client used. For example, if the client uses the connection string
``compressors=zlib,snappy`` the client will use ``zlib`` compression to send
data (if possible), but the server might still reply using ``snappy``,
depending on how the server was configured.
The driver must be built with zlib and/or snappy support to enable compression
support, any unknown (or not compiled in) compressor value will be ignored.
Additional Connection Options
-----------------------------
The full list of connection options can be found in the :symbol:`mongoc_uri_t` docs.
Certain socket/connection related options are not configurable:
============== ===================================================== ======================
Option Description Value
============== ===================================================== ======================
SO_KEEPALIVE TCP Keep Alive Enabled
-------------- ----------------------------------------------------- ----------------------
TCP_KEEPIDLE How long a connection needs to remain idle before TCP 300 seconds
starts sending keepalive probes
-------------- ----------------------------------------------------- ----------------------
TCP_KEEPINTVL The time in seconds between TCP probes 10 seconds
-------------- ----------------------------------------------------- ----------------------
TCP_KEEPCNT How many probes to send, without acknowledgement, 9 probes
before dropping the connection
-------------- ----------------------------------------------------- ----------------------
TCP_NODELAY Send packets as soon as possible or buffer small Enabled (no buffering)
packets (Nagle algorithm)
============== ===================================================== ======================
libmongoc-1.9.2+dfsg/doc/aggregate.rst 0000664 0000000 0000000 00000011201 13226174053 0017636 0 ustar 00root root 0000000 0000000 :man_page: mongoc_aggregate
Aggregation Framework Examples
==============================
This document provides a number of practical examples that display the capabilities of the aggregation framework.
The `Aggregations using the Zip Codes Data Set `_.
Requirements
------------
Let's check if everything is installed.
Use the following command to load zips.json data set into mongod instance:
.. code-block:: none
$ mongoimport --drop -d test -c zipcodes zips.json
Let's use the MongoDB shell to verify that everything was imported successfully.
.. code-block:: none
$ mongo test
MongoDB shell version: 2.6.1
connecting to: test
> db.zipcodes.count()
29467
> db.zipcodes.findOne()
{
"_id" : "35004",
"city" : "ACMAR",
"loc" : [
-86.51557,
33.584132
],
"pop" : 6055,
"state" : "AL"
}
Aggregations using the Zip Codes Data Set
-----------------------------------------
Each document in this collection has the following form:
.. code-block:: json
{
"_id" : "35004",
"city" : "Acmar",
"state" : "AL",
"pop" : 6055,
"loc" : [-86.51557, 33.584132]
}
In these documents:
* The ``_id`` field holds the zipcode as a string.
* The ``city`` field holds the city name.
* The ``state`` field holds the two letter state abbreviation.
* The ``pop`` field holds the population.
* The ``loc`` field holds the location as a ``[latitude, longitude]`` array.
States with Populations Over 10 Million
---------------------------------------
To get all states with a population greater than 10 million, use the following aggregation pipeline:
.. literalinclude:: ../examples/aggregation/aggregation1.c
:language: c
:caption: aggregation1.c
You should see a result like the following:
.. code-block:: json
{ "_id" : "PA", "total_pop" : 11881643 }
{ "_id" : "OH", "total_pop" : 10847115 }
{ "_id" : "NY", "total_pop" : 17990455 }
{ "_id" : "FL", "total_pop" : 12937284 }
{ "_id" : "TX", "total_pop" : 16986510 }
{ "_id" : "IL", "total_pop" : 11430472 }
{ "_id" : "CA", "total_pop" : 29760021 }
The above aggregation pipeline is build from two pipeline operators: ``$group`` and ``$match``.
The ``$group`` pipeline operator requires _id field where we specify grouping; remaining fields specify how to generate composite value and must use one of the group aggregation functions: ``$addToSet``, ``$first``, ``$last``, ``$max``, ``$min``, ``$avg``, ``$push``, ``$sum``. The ``$match`` pipeline operator syntax is the same as the read operation query syntax.
The ``$group`` process reads all documents and for each state it creates a separate document, for example:
.. code-block:: json
{ "_id" : "WA", "total_pop" : 4866692 }
The ``total_pop`` field uses the $sum aggregation function to sum the values of all pop fields in the source documents.
Documents created by ``$group`` are piped to the ``$match`` pipeline operator. It returns the documents with the value of ``total_pop`` field greater than or equal to 10 million.
Average City Population by State
--------------------------------
To get the first three states with the greatest average population per city, use the following aggregation:
.. code-block:: c
pipeline = BCON_NEW ("pipeline", "[",
"{", "$group", "{", "_id", "{", "state", "$state", "city", "$city", "}", "pop", "{", "$sum", "$pop", "}", "}", "}",
"{", "$group", "{", "_id", "$_id.state", "avg_city_pop", "{", "$avg", "$pop", "}", "}", "}",
"{", "$sort", "{", "avg_city_pop", BCON_INT32 (-1), "}", "}",
"{", "$limit", BCON_INT32 (3) "}",
"]");
This aggregate pipeline produces:
.. code-block:: json
{ "_id" : "DC", "avg_city_pop" : 303450.0 }
{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }
{ "_id" : "CA", "avg_city_pop" : 27735.341099720412 }
The above aggregation pipeline is build from three pipeline operators: ``$group``, ``$sort`` and ``$limit``.
The first ``$group`` operator creates the following documents:
.. code-block:: json
{ "_id" : { "state" : "WY", "city" : "Smoot" }, "pop" : 414 }
Note, that the ``$group`` operator can't use nested documents except the ``_id`` field.
The second ``$group`` uses these documents to create the following documents:
.. code-block:: json
{ "_id" : "FL", "avg_city_pop" : 27942.29805615551 }
These documents are sorted by the ``avg_city_pop`` field in descending order. Finally, the ``$limit`` pipeline operator returns the first 3 documents from the sorted set.
libmongoc-1.9.2+dfsg/doc/api.rst 0000664 0000000 0000000 00000002135 13226174053 0016467 0 ustar 00root root 0000000 0000000 API Reference
=============
.. toctree::
:titlesonly:
:maxdepth: 1
init-cleanup
logging
errors
lifecycle
mongoc_bulk_operation_t
mongoc_change_stream_t
mongoc_client_pool_t
mongoc_client_session_t
mongoc_client_t
mongoc_collection_t
mongoc_cursor_t
mongoc_database_t
mongoc_delete_flags_t
mongoc_find_and_modify_opts_t
mongoc_gridfs_file_list_t
mongoc_gridfs_file_opt_t
mongoc_gridfs_file_t
mongoc_gridfs_t
mongoc_host_list_t
mongoc_index_opt_geo_t
mongoc_index_opt_t
mongoc_index_opt_wt_t
mongoc_insert_flags_t
mongoc_iovec_t
mongoc_matcher_t
mongoc_query_flags_t
mongoc_rand
mongoc_read_concern_t
mongoc_read_mode_t
mongoc_read_prefs_t
mongoc_remove_flags_t
mongoc_reply_flags_t
mongoc_server_description_t
mongoc_session_opt_t
mongoc_socket_t
mongoc_ssl_opt_t
mongoc_stream_buffered_t
mongoc_stream_file_t
mongoc_stream_socket_t
mongoc_stream_t
mongoc_stream_tls_t
mongoc_topology_description_t
mongoc_update_flags_t
mongoc_uri_t
mongoc_version
mongoc_write_concern_t
libmongoc-1.9.2+dfsg/doc/application-performance-monitoring.rst 0000664 0000000 0000000 00000011214 13226174053 0024701 0 ustar 00root root 0000000 0000000 :man_page: mongoc_application_performance_monitoring
Application Performance Monitoring (APM)
========================================
The MongoDB C Driver allows you to monitor all the MongoDB operations the driver executes. This event-notification system conforms to two MongoDB driver specs:
* `Command Monitoring `_: events related to all application operations.
* `SDAM Monitoring `_: events related to the driver's Server Discovery And Monitoring logic.
To receive notifications, create a ``mongoc_apm_callbacks_t`` with :symbol:`mongoc_apm_callbacks_new`, set callbacks on it, then pass it to :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
Command-Monitoring Example
--------------------------
.. literalinclude:: ../examples/example-command-monitoring.c
:language: c
:caption: example-command-monitoring.c
This example program prints:
.. code-block:: none
Command drop started on 127.0.0.1:
{ "drop" : "test" }
Command drop succeeded:
{ "ns" : "test.test", "nIndexesWas" : 1, "ok" : 1.0 }
Command insert started on 127.0.0.1:
{
"insert" : "test",
"ordered" : true,
"documents" : [
{ "_id" : 0 }, { "_id" : 1 }
]
}
Command insert succeeded:
{ "n" : 2, "ok" : 1.0 }
Command insert started on 127.0.0.1:
{
"insert" : "test",
"ordered" : true,
"documents" : [
{ "_id" : 0 }
]
}
Command insert succeeded:
{
"n" : 0,
"writeErrors" : [
{ "index" : 0, "code" : 11000, "errmsg" : "duplicate key" }
],
"ok" : 1.0
}
started: 3
succeeded: 3
failed: 0
The output has been edited and formatted for clarity. Depending on your server configuration, messages may include metadata like database name, logical session ids, or cluster times that are not shown here.
The final "insert" command is considered successful, despite the writeError, because the server replied to the overall command with ``"ok": 1``.
SDAM Monitoring Example
-----------------------
.. literalinclude:: ../examples/example-sdam-monitoring.c
:language: c
:caption: example-sdam-monitoring.c
Start a 3-node replica set on localhost with set name "rs" and start the program:
.. code-block:: none
./example-sdam-monitoring "mongodb://localhost:27017,localhost:27018/?replicaSet=rs"
This example program prints something like:
.. code-block:: none
topology opening
topology changed: Unknown -> ReplicaSetNoPrimary
server opening: localhost:27017
server opening: localhost:27018
localhost:27017 heartbeat started
localhost:27018 heartbeat started
localhost:27017 heartbeat succeeded: { ... reply ... }
server changed: localhost:27017 Unknown -> RSPrimary
server opening: localhost:27019
topology changed: ReplicaSetNoPrimary -> ReplicaSetWithPrimary
new servers:
RSPrimary localhost:27017
localhost:27019 heartbeat started
localhost:27018 heartbeat succeeded: { ... reply ... }
server changed: localhost:27018 Unknown -> RSSecondary
topology changed: ReplicaSetWithPrimary -> ReplicaSetWithPrimary
previous servers:
RSPrimary localhost:27017
new servers:
RSPrimary localhost:27017
RSSecondary localhost:27018
localhost:27019 heartbeat succeeded: { ... reply ... }
server changed: localhost:27019 Unknown -> RSSecondary
topology changed: ReplicaSetWithPrimary -> ReplicaSetWithPrimary
previous servers:
RSPrimary localhost:27017
RSSecondary localhost:27018
new servers:
RSPrimary localhost:27017
RSSecondary localhost:27018
RSSecondary localhost:27019
topology closed
Events:
server changed: 3
server opening: 3
server closed: 0
topology changed: 4
topology opening: 1
topology closed: 1
heartbeat started: 3
heartbeat succeeded: 3
heartbeat failed: 0
The driver discovers the third member, "localhost:27019", and adds it to the topology.
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_callbacks_t
mongoc_apm_command_failed_t
mongoc_apm_command_started_t
mongoc_apm_command_succeeded_t
mongoc_apm_server_changed_t
mongoc_apm_server_closed_t
mongoc_apm_server_heartbeat_failed_t
mongoc_apm_server_heartbeat_started_t
mongoc_apm_server_heartbeat_succeeded_t
mongoc_apm_server_opening_t
mongoc_apm_topology_changed_t
mongoc_apm_topology_closed_t
mongoc_apm_topology_opening_t
libmongoc-1.9.2+dfsg/doc/authentication.rst 0000664 0000000 0000000 00000016543 13226174053 0020745 0 ustar 00root root 0000000 0000000 :man_page: mongoc_authentication
Authentication
==============
This guide covers the use of authentication options with the MongoDB C Driver. Ensure that the MongoDB server is also properly configured for authentication before making a connection. For more information, see the `MongoDB security documentation `
* :ref:`MONGODB-CR `
* :ref:`GSSAPI `
* :ref:`PLAIN `
* :ref:`X509 `
.. _authentication_scram_sha_1:
Basic Authentication (SCRAM-SHA-1)
----------------------------------
The default authentication mechanism when talking to MongoDB 3.0 and later is ``SCRAM-SHA-1`` (`RFC 5802 `_). Using this authentication mechanism means that the password is never actually sent over the wire when authenticating, but rather a computed proof that the client password is the same as the password the server knows.
.. code-block:: none
mongoc_client_t *client = mongoc_client_new ("mongodb://user:password@localhost/?authMechanism=SCRAM-SHA-1&authSource=mydb");
.. note::
``SCRAM-SHA-1`` authenticates against the ``admin`` database by default. If the user is created in another database, then specifying the authSource is required.
.. _authentication_mongodbcr:
Legacy Authentication (MONGODB-CR)
----------------------------------
The MONGODB-CR authMechanism is a challenge response authentication mechanism. It was the default mechanism until MongoDB 3.0 and is being phased out. It is strongly suggested that users upgrade to SCRAM-SHA-1.
.. note::
``MONGODB-CR`` authenticates against the ``admin`` database by default. If the user is created in another database, then specifying the authSource is required.
.. _authentication_kerberos:
GSSAPI (Kerberos) Authentication
--------------------------------
.. note::
Kerberos support requires compiling the driver against ``cyrus-sasl`` on UNIX-like environments. On Windows, configure the driver to build against the Windows Native SSPI.
``GSSAPI`` (Kerberos) authentication is available in the Enterprise Edition of MongoDB. To authenticate using ``GSSAPI``, the MongoDB C driver must be installed with SASL support.
On UNIX-like environments, run the ``kinit`` command before using the following authentication methods:
.. code-block:: none
$ kinit mongodbuser@EXAMPLE.COM
mongodbuser@EXAMPLE.COM's Password:
$ klistCredentials cache: FILE:/tmp/krb5cc_1000
Principal: mongodbuser@EXAMPLE.COM
Issued Expires Principal
Feb 9 13:48:51 2013 Feb 9 23:48:51 2013 krbtgt/EXAMPLE.COM@EXAMPLE.COM
Now authenticate using the MongoDB URI. ``GSSAPI`` authenticates against the ``$external`` virtual database, so a database does not need to be specified in the URI. Note that the Kerberos principal *must* be URL-encoded:
.. code-block:: none
mongoc_client_t *client;
client = mongoc_client_new ("mongodb://mongodbuser%40EXAMPLE.COM@mongo-server.example.com/?authMechanism=GSSAPI");
.. note::
``GSSAPI`` authenticates against the ``$external`` database, so specifying the authSource database is not required.
The driver supports these GSSAPI properties:
* ``CANONICALIZE_HOST_NAME``: This might be required with Cyrus-SASL when the hosts report different hostnames than what is used in the Kerberos database. The default is "false".
* ``SERVICE_NAME``: Use a different service name than the default, "mongodb".
Set properties in the URL:
.. code-block:: none
mongoc_client_t *client;
client = mongoc_client_new ("mongodb://mongodbuser%40EXAMPLE.COM@mongo-server.example.com/?authMechanism=GSSAPI&"
"authMechanismProperties=SERVICE_NAME:other,CANONICALIZE_HOST_NAME:true");
If you encounter errors such as ``Invalid net address``, check if the application is behind a NAT (Network Address Translation) firewall. If so, create a ticket that uses ``forwardable`` and ``addressless`` Kerberos tickets. This can be done by passing ``-f -A`` to ``kinit``.
.. code-block:: none
$ kinit -f -A mongodbuser@EXAMPLE.COM
.. _authentication_plain:
SASL Plain Authentication
-------------------------
.. note::
The MongoDB C Driver must be compiled with SASL support in order to use ``SASL PLAIN`` authentication.
MongoDB Enterprise Edition supports the ``SASL PLAIN`` authentication mechanism, initially intended for delegating authentication to an LDAP server. Using the ``SASL PLAIN`` mechanism is very similar to the challenge response mechanism with usernames and passwords. This authentication mechanism uses the ``$external`` virtual database for ``LDAP`` support:
.. note::
``SASL PLAIN`` is a clear-text authentication mechanism. It is strongly recommended to connect to MongoDB using SSL with certificate validation when using the ``PLAIN`` mechanism.
.. code-block:: none
mongoc_client_t *client;
client = mongoc_client_new ("mongodb://user:password@example.com/?authMechanism=PLAIN");
``PLAIN`` authenticates against the ``$external`` database, so specifying the authSource database is not required.
.. _authentication_x509:
X.509 Certificate Authentication
--------------------------------
.. note::
The MongoDB C Driver must be compiled with SSL support for X.509 authentication support. Once this is done, start a server with the following options:
.. code-block:: none
$ mongod --sslMode requireSSL --sslPEMKeyFile server.pem --sslCAFile ca.pem
The ``MONGODB-X509`` mechanism authenticates a username derived from the distinguished subject name of the X.509 certificate presented by the driver during SSL negotiation. This authentication method requires the use of SSL connections with certificate validation.
.. code-block:: none
mongoc_client_t *client;
mongoc_ssl_opt_t ssl_opts = { 0 };
ssl_opts.pem_file = "mycert.pem";
ssl_opts.pem_pwd = "mycertpassword";
ssl_opts.ca_file = "myca.pem";
ssl_opts.ca_dir = "trust_dir";
ssl_opts.weak_cert_validation = false;
client = mongoc_client_new ("mongodb://x509_derived_username@localhost/?authMechanism=MONGODB-X509");
mongoc_client_set_ssl_opts (client, &ssl_opts);
``MONGODB-X509`` authenticates against the ``$external`` database, so specifying the authSource database is not required. For more information on the x509_derived_username, see the MongoDB server `x.509 tutorial `_.
.. note::
The MongoDB C Driver will attempt to determine the x509 derived username when none is provided, and as of MongoDB 3.4 providing the username is not required at all.
.. only:: html
.. taglist:: See Also:
:tags: authmechanism
libmongoc-1.9.2+dfsg/doc/basic-troubleshooting.rst 0000664 0000000 0000000 00000012651 13226174053 0022230 0 ustar 00root root 0000000 0000000 :man_page: mongoc_basic_troubleshooting
Basic Troubleshooting
=====================
Troubleshooting Checklist
-------------------------
The following is a short list of things to check when you have a problem.
* Did you call ``mongoc_init()`` in ``main()``? If not, you will likely see a segfault.
* Have you leaked any clients or cursors as can be found with ``mongoc-stat ``?
* Have packets been delivered to the server? See egress bytes from ``mongoc-stat ``.
* Does ``valgrind`` show any leaks? Ensure you call ``mongoc_cleanup()`` at the end of your process to cleanup lingering allocations from the MongoDB C driver.
* If compiling your own copy of MongoDB C driver, consider configuring with ``--enable-tracing`` to enable function tracing and hex dumps of network packets to ``STDERR`` and ``STDOUT``.
Performance Counters
--------------------
The MongoDB C driver comes with a unique feature to help developers and sysadmins troubleshoot problems in production.
Performance counters are available for each process using the driver.
The counters can be accessed outside of the application process via a shared memory segment.
This means that you can graph statistics about your application process easily from tools like Munin or Nagios.
Your author often uses ``watch --interval=0.5 -d mongoc-stat $PID`` to monitor an application.
Counters are currently available on UNIX-like platforms that support shared memory segments.
* Active and Disposed Cursors
* Active and Disposed Clients, Client Pools, and Socket Streams.
* Number of operations sent and received, by type.
* Bytes transferred and received.
* Authentication successes and failures.
* Number of wire protocol errors.
To access counters for a given process, simply provide the process id to the ``mongoc-stat`` program installed with the MongoDB C Driver.
.. code-block:: none
$ mongoc-stat 22203
Operations : Egress Total : The number of sent operations. : 13247
Operations : Ingress Total : The number of received operations. : 13246
Operations : Egress Queries : The number of sent Query operations. : 13247
Operations : Ingress Queries : The number of received Query operations. : 0
Operations : Egress GetMore : The number of sent GetMore operations. : 0
Operations : Ingress GetMore : The number of received GetMore operations. : 0
Operations : Egress Insert : The number of sent Insert operations. : 0
Operations : Ingress Insert : The number of received Insert operations. : 0
Operations : Egress Delete : The number of sent Delete operations. : 0
Operations : Ingress Delete : The number of received Delete operations. : 0
Operations : Egress Update : The number of sent Update operations. : 0
Operations : Ingress Update : The number of received Update operations. : 0
Operations : Egress KillCursors : The number of sent KillCursors operations. : 0
Operations : Ingress KillCursors : The number of received KillCursors operations. : 0
Operations : Egress Msg : The number of sent Msg operations. : 0
Operations : Ingress Msg : The number of received Msg operations. : 0
Operations : Egress Reply : The number of sent Reply operations. : 0
Operations : Ingress Reply : The number of received Reply operations. : 13246
Cursors : Active : The number of active cursors. : 1
Cursors : Disposed : The number of disposed cursors. : 13246
Clients : Active : The number of active clients. : 1
Clients : Disposed : The number of disposed clients. : 0
Streams : Active : The number of active streams. : 1
Streams : Disposed : The number of disposed streams. : 0
Streams : Egress Bytes : The number of bytes sent. : 794931
Streams : Ingress Bytes : The number of bytes received. : 589694
Streams : N Socket Timeouts : The number of socket timeouts. : 0
Client Pools : Active : The number of active client pools. : 1
Client Pools : Disposed : The number of disposed client pools. : 0
Protocol : Ingress Errors : The number of protocol errors on ingress. : 0
Auth : Failures : The number of failed authentication requests. : 0
Auth : Success : The number of successful authentication requests. : 0
.. _basic-troubleshooting_file_bug:
Submitting a Bug Report
-----------------------
Think you've found a bug? Want to see a new feature in the MongoDB C driver? Please open a case in our issue management tool, JIRA:
* `Create an account and login `_.
* Navigate to `the CDRIVER project `_.
* Click *Create Issue* - Please provide as much information as possible about the issue type and how to reproduce it.
Bug reports in JIRA for all driver projects (i.e. CDRIVER, CSHARP, JAVA) and the Core Server (i.e. SERVER) project are *public*.
libmongoc-1.9.2+dfsg/doc/bulk.rst 0000664 0000000 0000000 00000015002 13226174053 0016650 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk
Bulk Write Operations
=====================
This tutorial explains how to take advantage of MongoDB C driver bulk write operation features. Executing write operations in batches reduces the number of network round trips, increasing write throughput.
Bulk Insert
-----------
First we need to fetch a bulk operation handle from the :symbol:`mongoc_collection_t`.
.. code-block:: c
mongoc_bulk_operation_t *bulk =
mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
We can now start inserting documents to the bulk operation. These will be buffered until we execute the operation.
The bulk operation will coalesce insertions as a single batch for each consecutive call to :symbol:`mongoc_bulk_operation_insert()`. This creates a pipelined effect when possible.
To execute the bulk operation and receive the result we call :symbol:`mongoc_bulk_operation_execute()`.
.. literalinclude:: ../examples/bulk/bulk1.c
:language: c
:caption: bulk1.c
Example ``reply`` document:
.. code-block:: none
{"nInserted" : 10000,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"nUpserted" : 0,
"writeErrors" : []
"writeConcernErrors" : [] }
Mixed Bulk Write Operations
---------------------------
MongoDB C driver also supports executing mixed bulk write operations. A batch of insert, update, and remove operations can be executed together using the bulk write operations API.
Ordered Bulk Write Operations
-----------------------------
Ordered bulk write operations are batched and sent to the server in the order provided for serial execution. The ``reply`` document describes the type and count of operations performed.
.. literalinclude:: ../examples/bulk/bulk2.c
:language: c
:caption: bulk2.c
Example ``reply`` document:
.. code-block:: none
{ "nInserted" : 3,
"nMatched" : 2,
"nModified" : 2,
"nRemoved" : 10000,
"nUpserted" : 1,
"upserted" : [{"index" : 5, "_id" : 4}],
"writeErrors" : []
"writeConcernErrors" : [] }
The ``index`` field in the ``upserted`` array is the 0-based index of the upsert operation; in this example, the sixth operation of the overall bulk operation was an upsert, so its index is 5.
Unordered Bulk Write Operations
-------------------------------
Unordered bulk write operations are batched and sent to the server in *arbitrary order* where they may be executed in parallel. Any errors that occur are reported after all operations are attempted.
In the next example the first and third operations fail due to the unique constraint on ``_id``. Since we are doing unordered execution the second and fourth operations succeed.
.. literalinclude:: ../examples/bulk/bulk3.c
:language: c
:caption: bulk3.c
Example ``reply`` document:
.. code-block:: none
{ "nInserted" : 0,
"nMatched" : 1,
"nModified" : 1,
"nRemoved" : 1,
"nUpserted" : 0,
"writeErrors" : [
{ "index" : 0,
"code" : 11000,
"errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }" },
{ "index" : 2,
"code" : 11000,
"errmsg" : "E11000 duplicate key error index: test.test.$_id_ dup key: { : 3 }" } ],
"writeConcernErrors" : [] }
Error: E11000 duplicate key error index: test.test.$_id_ dup key: { : 1 }
The :symbol:`bson_error_t ` domain is ``MONGOC_ERROR_COMMAND`` and its code is 11000.
.. _bulk_operation_bypassing_document_validation:
Bulk Operation Bypassing Document Validation
--------------------------------------------
This feature is only available when using MongoDB 3.2 and later.
By default bulk operations are validated against the schema, if any is defined. In certain cases however it may be necessary to bypass the document validation.
.. literalinclude:: ../examples/bulk/bulk5.c
:language: c
:caption: bulk5.c
Running the above example will result in:
.. code-block:: none
{ "nInserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"nUpserted" : 0,
"writeErrors" : [
{ "index" : 0,
"code" : 121,
"errmsg" : "Document failed validation" } ] }
Error: Document failed validation
{ "nInserted" : 2,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"nUpserted" : 0,
"writeErrors" : [] }
The :symbol:`bson_error_t ` domain is ``MONGOC_ERROR_COMMAND``.
Bulk Operation Write Concerns
-----------------------------
By default bulk operations are executed with the :symbol:`write_concern ` of the collection they are executed against. A custom write concern can be passed to the :symbol:`mongoc_collection_create_bulk_operation_with_opts()` method. Write concern errors (e.g. wtimeout) will be reported after all operations are attempted, regardless of execution order.
.. literalinclude:: ../examples/bulk/bulk4.c
:language: c
:caption: bulk4.c
Example ``reply`` document and error message:
.. code-block:: none
{ "nInserted" : 2,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"nUpserted" : 0,
"writeErrors" : [],
"writeConcernErrors" : [
{ "code" : 64,
"errmsg" : "waiting for replication timed out" }
] }
Error: waiting for replication timed out
The :symbol:`bson_error_t ` domain is ``MONGOC_ERROR_WRITE_CONCERN`` if there are write concern errors and no write errors. Write errors indicate failed operations, so they take precedence over write concern errors, which mean merely that the write concern is not satisfied *yet*.
.. _setting_collation_order:
Setting Collation Order
-----------------------
This feature is only available when using MongoDB 3.4 and later.
.. literalinclude:: ../examples/bulk/bulk-collation.c
:language: c
:caption: bulk-collation.c
Running the above example will result in:
.. code-block:: none
{ "nInserted" : 2,
"nMatched" : 1,
"nModified" : 1,
"nRemoved" : 0,
"nUpserted" : 0,
"writeErrors" : [ ]
}
Unacknowledged Bulk Writes
--------------------------
Set "w" to zero for an unacknowledged write. The driver sends unacknowledged writes using the legacy opcodes ``OP_INSERT``, ``OP_UPDATE``, and ``OP_DELETE``.
.. literalinclude:: ../examples/bulk/bulk6.c
:language: c
:caption: bulk6.c
The ``reply`` document is empty:
.. code-block:: none
{ }
Further Reading
---------------
See the `Driver Bulk API Spec `_, which describes bulk write operations for all MongoDB drivers.
libmongoc-1.9.2+dfsg/doc/conf.py 0000664 0000000 0000000 00000011505 13226174053 0016464 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
import os.path
import sys
from sphinx import version_info as sphinx_version_info
# Ensure we can import "mongoc" and "taglist" extension modules.
sys.path.append(os.path.dirname(__file__))
extensions = [
'mongoc',
'taglist',
'sphinx.ext.intersphinx',
'sphinx.ext.extlinks',
]
# General information about the project.
project = 'MongoDB C Driver'
copyright = '2017, MongoDB, Inc'
author = 'MongoDB, Inc'
version_path = os.path.join(os.path.dirname(__file__), '..', 'VERSION_CURRENT')
version = open(version_path).read().strip()
release_path = os.path.join(os.path.dirname(__file__), '..', 'VERSION_RELEASED')
release = open(release_path).read().strip()
release_major, release_minor, release_patch = release.split('.')
release_download = 'https://github.com/mongodb/mongo-c-driver/releases/download/{0}/mongo-c-driver-{0}.tar.gz'.format(release)
rst_prolog = """
.. |release_major| replace:: %(release_major)s
.. |release_minor| replace:: %(release_minor)s
.. |release_patch| replace:: %(release_patch)s
.. |release_download| replace:: https://github.com/mongodb/mongo-c-driver/releases/download/%(release)s/mongo-c-driver-%(release)s.tar.gz
""" % locals()
# The extension requires the "base" to contain '%s' exactly once, but we never intend to use it though
extlinks = {'release': (release_download+'%s', '')}
language = 'en'
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
master_doc = 'index'
# don't fetch libbson's inventory from mongoc.org during build - Debian and
# Fedora package builds must work offline - maintain a recent copy here
intersphinx_mapping = {
'bson': ('http://mongoc.org/libbson/current', 'libbson-objects.inv'),
}
# -- Options for HTML output ----------------------------------------------
html_theme_path = ['.']
html_theme = 'mongoc-theme'
html_title = html_shorttitle = 'MongoDB C Driver %s' % version
# html_favicon = None
if sphinx_version_info >= (1, 6):
smart_quotes = False
else:
html_use_smartypants = False
html_sidebars = {
'**': ['globaltoc.html'],
'errors': [], # Make more room for the big table.
'mongoc_uri_t': [], # Make more room for the big table.
}
html_show_sourcelink = False
# Note: http://www.sphinx-doc.org/en/1.5.1/config.html#confval-html_copy_source
# This will degrade the Javascript quicksearch if we ever use it.
html_copy_source = False
# -- Options for manual page output ---------------------------------------
# HACK: Just trick Sphinx's ManualPageBuilder into thinking there are pages
# configured - we'll do it dynamically in process_nodes.
man_pages = [True]
# If true, show URL addresses after external links.
#
# man_show_urls = False
from docutils.nodes import title
# To publish HTML docs at GitHub Pages, create .nojekyll file. In Sphinx 1.4 we
# could use the githubpages extension, but old Ubuntu still has Sphinx 1.3.
def create_nojekyll(app, env):
if app.builder.format == 'html':
path = os.path.join(app.builder.outdir, '.nojekyll')
with open(path, 'wt') as f:
f.write('foo')
def add_ga_javascript(app, pagename, templatename, context, doctree):
if not app.env.config.analytics:
return
context['metatags'] = context.get('metatags', '') + """"""
def add_canonical_link(app, pagename, templatename, context, doctree):
link = ('' % pagename)
context['metatags'] = context.get('metatags', '') + link
def setup(app):
app.connect('doctree-read', process_nodes)
app.connect('env-updated', create_nojekyll)
app.connect('html-page-context', add_ga_javascript)
# Run sphinx-build -D analytics=1 to enable Google Analytics.
app.add_config_value('analytics', False, 'html')
app.connect('html-page-context', add_canonical_link)
def process_nodes(app, doctree):
if man_pages == [True]:
man_pages.pop()
env = app.env
metadata = env.metadata[env.docname]
# A page like installing.rst sets its name with ":man_page: mongoc_installing"
page_name = metadata.get('man_page')
if not page_name:
print('Not creating man page for %s' % env.docname)
return
page_title = find_node(doctree, title)
man_pages.append((env.docname, page_name, page_title.astext(), [author], 3))
def find_node(doctree, klass):
matches = doctree.traverse(lambda node: isinstance(node, klass))
if not matches:
raise IndexError("No %s in %s" % (klass, doctree))
return matches[0]
libmongoc-1.9.2+dfsg/doc/connection-pooling.rst 0000664 0000000 0000000 00000007161 13226174053 0021526 0 ustar 00root root 0000000 0000000 :man_page: mongoc_connection_pooling
Connection Pooling
==================
The MongoDB C driver has two connection modes: single-threaded and pooled. Single-threaded mode is optimized for embedding the driver within languages like PHP. Multi-threaded programs should use pooled mode: this mode minimizes the total connection count, and in pooled mode a background thread monitors the MongoDB server topology, so the program need not block to scan it.
Single Mode
-----------
In single mode, your program creates a :symbol:`mongoc_client_t` directly:
.. code-block:: c
mongoc_client_t *client = mongoc_client_new (
"mongodb://hostA,hostB/?replicaSet=my_rs");
The client connects on demand when your program first uses it for a MongoDB operation. Using a non-blocking socket per server, it begins a check on each server concurrently, and uses the asynchronous ``poll`` or ``select`` function to receive events from the sockets, until all have responded or timed out. Put another way, in single-threaded mode the C Driver fans out to begin all checks concurrently, then fans in once all checks have completed or timed out. Once the scan completes, the client executes your program's operation and returns.
In single mode, the client re-scans the server topology roughly once per minute. If more than a minute has elapsed since the previous scan, the next operation on the client will block while the client completes its scan. This interval is configurable with ``heartbeatFrequencyMS`` in the connection string. (See :symbol:`mongoc_uri_t`.)
A single client opens one connection per server in your topology: these connections are used both for scanning the topology and performing normal operations.
Pooled Mode
-----------
To activate pooled mode, create a :symbol:`mongoc_client_pool_t`:
.. code-block:: c
mongoc_uri_t *uri = mongoc_uri_new (
"mongodb://hostA,hostB/?replicaSet=my_rs");
mongoc_client_pool_t *pool = mongoc_client_pool_new (uri);
When your program first calls :symbol:`mongoc_client_pool_pop`, the pool launches a background thread for monitoring. The thread fans out and connects to all servers in the connection string, using non-blocking sockets and a simple event loop. As it receives ismaster responses from the servers, it updates its view of the server topology. Each time the thread discovers a new server it begins connecting to it, and adds the new socket to the list of non-blocking sockets in the event loop.
Each thread that executes MongoDB operations must check out a client from the pool:
.. code-block:: c
mongoc_client_t *client = mongoc_client_pool_pop (pool);
/* use the client for operations ... */
mongoc_client_pool_push (pool, client);
The :symbol:`mongoc_client_t` object is not thread-safe, only the :symbol:`mongoc_client_pool_t` is.
When the driver is in pooled mode, your program's operations are unblocked as soon as monitoring discovers a usable server. For example, if a thread in your program is waiting to execute an "insert" on the primary, it is unblocked as soon as the primary is discovered, rather than waiting for all secondaries to be checked as well.
The pool opens one connection per server for monitoring, and each client opens its own connection to each server it uses for application operations. The background thread re-scans the server topology roughly every 10 seconds. This interval is configurable with ``heartbeatFrequencyMS`` in the connection string. (See :symbol:`mongoc_uri_t`.)
See :ref:`connection_pool_options` to configure pool size and behavior, and see :symbol:`mongoc_client_pool_t` for an extended example of a multi-threaded program that uses the driver in pooled mode.
libmongoc-1.9.2+dfsg/doc/create-indexes.rst 0000664 0000000 0000000 00000000735 13226174053 0020622 0 ustar 00root root 0000000 0000000 :man_page: mongoc_create_indexes
Creating Indexes
================
To create indexes on a MongoDB collection, execute the ``createIndexes`` command
with :symbol:`mongoc_database_write_command_with_opts`. See `the MongoDB
Manual entry for the createIndexes command
`.
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|Domain | Code | Description |
+===================================+=================================================================================================================================+============================================================================================================================================================================================================================================================================================================================================+
| ``MONGOC_ERROR_CLIENT`` | ``MONGOC_ERROR_CLIENT_TOO_BIG`` | You tried to send a message larger than the server's max message size. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_CLIENT_AUTHENTICATE`` | Wrong credentials, or failure sending or receiving authentication messages. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_CLIENT_NO_ACCEPTABLE_PEER`` | You tried an SSL connection but the driver was not built with SSL. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_CLIENT_IN_EXHAUST`` | You began iterating an exhaust cursor, then tried to begin another operation with the same :symbol:`mongoc_client_t`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_CLIENT_SESSION_FAILURE`` | Failure related to creating or using a logical session. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_STREAM`` | ``MONGOC_ERROR_STREAM_NAME_RESOLUTION`` | DNS failure. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_STREAM_SOCKET`` | Timeout communicating with server, or connection closed. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_STREAM_CONNECT`` | Failed to connect to server. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_PROTOCOL`` | ``MONGOC_ERROR_PROTOCOL_INVALID_REPLY`` | Corrupt response from server. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION`` | The server version is too old or too new to communicate with the driver. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_CURSOR`` | ``MONGOC_ERROR_CURSOR_INVALID_CURSOR`` | You passed bad arguments to :symbol:`mongoc_collection_find_with_opts`, or you called :symbol:`mongoc_cursor_next` on a completed or failed cursor, or the cursor timed out on the server. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_CHANGE_STREAM_NO_RESUME_TOKEN`` | A resume token was not returned in a document found with :symbol:`mongoc_change_stream_next` |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_QUERY`` | ``MONGOC_ERROR_QUERY_FAILURE`` | :ref:`Error API Version 1 `: Server error from command or query. The server error message is in ``message``. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_SERVER`` | ``MONGOC_ERROR_QUERY_FAILURE`` | :ref:`Error API Version 2 `: Server error from command or query. The server error message is in ``message``. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_SASL`` | A SASL error code. | ``man sasl_errors`` for a list of codes. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_BSON`` | ``MONGOC_ERROR_BSON_INVALID`` | You passed an invalid or oversized BSON document as a parameter, or called :symbol:`mongoc_collection_create_index` with invalid keys, or the server reply was corrupt. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_NAMESPACE`` | ``MONGOC_ERROR_NAMESPACE_INVALID`` | You tried to create a collection with an invalid name. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_COMMAND`` | ``MONGOC_ERROR_COMMAND_INVALID_ARG`` | Many functions set this error code when passed bad parameters. Print the error message for details. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION`` | You tried to use a command option the server does not support. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_DUPLICATE_KEY`` | An insert or update failed because because of a duplicate ``_id`` or other unique-index violation. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_COMMAND`` | `Error code from server `_. | :ref:`Error API Version 1 `: Server error from a command. The server error message is in ``message``. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_SERVER`` | `Error code from server `_. | :ref:`Error API Version 2 `: Server error from a command. The server error message is in ``message``. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_COLLECTION`` | ``MONGOC_ERROR_COLLECTION_INSERT_FAILED``, ``MONGOC_ERROR_COLLECTION_UPDATE_FAILED``, ``MONGOC_ERROR_COLLECTION_DELETE_FAILED``.| Invalid or empty input to :symbol:`mongoc_collection_insert_one`, :symbol:`mongoc_collection_insert_bulk`, :symbol:`mongoc_collection_update_one`, :symbol:`mongoc_collection_update_many`, :symbol:`mongoc_collection_replace_one`, :symbol:`mongoc_collection_delete_one`, or :symbol:`mongoc_collection_delete_many`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_COLLECTION`` | `Error code from server `_. | :ref:`Error API Version 1 `: Server error from :symbol:`mongoc_collection_insert_one`, :symbol:`mongoc_collection_insert_bulk`, :symbol:`mongoc_collection_update_one`, :symbol:`mongoc_collection_update_many`, :symbol:`mongoc_collection_replace_one`, |
| | | :symbol:`mongoc_collection_delete_one`, or :symbol:`mongoc_collection_delete_many`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_SERVER`` | `Error code from server `_. | :ref:`Error API Version 2 `: Server error from :symbol:`mongoc_collection_insert_one`, :symbol:`mongoc_collection_insert_bulk`, :symbol:`mongoc_collection_update_one`, :symbol:`mongoc_collection_update_many`, :symbol:`mongoc_collection_replace_one`, |
| | | :symbol:`mongoc_collection_delete_one`, or :symbol:`mongoc_collection_delete_many`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_GRIDFS`` | ``MONGOC_ERROR_GRIDFS_CHUNK_MISSING`` | The GridFS file is missing a document in its ``chunks`` collection. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_GRIDFS_INVALID_FILENAME`` | You passed a NULL filename to :symbol:`mongoc_gridfs_remove_by_filename`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | ``MONGOC_ERROR_GRIDFS_PROTOCOL_ERROR`` | You called :symbol:`mongoc_gridfs_file_set_id` after :symbol:`mongoc_gridfs_file_save`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_SCRAM`` | ``MONGOC_ERROR_SCRAM_PROTOCOL_ERROR`` | Failure in SCRAM-SHA-1 authentication. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_SERVER_SELECTION`` | ``MONGOC_ERROR_SERVER_SELECTION_FAILURE`` | No replica set member or mongos is available, or none matches your :doc:`read preference `, or you supplied an invalid :symbol:`mongoc_read_prefs_t`. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ``MONGOC_ERROR_WRITE_CONCERN`` | `Error code from server `_. | There was a :doc:`write concern ` error or :doc:`timeout ` from the server. |
+-----------------------------------+---------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. _errors_error_api_version:
.. _error_api_version:
Setting the Error API Version
-----------------------------
The driver's error reporting began with a design flaw: when the error *domain* is ``MONGOC_ERROR_COLLECTION``, ``MONGOC_ERROR_QUERY``, or ``MONGOC_ERROR_COMMAND``, the error *code* might originate from the server or the driver. An application cannot always know where an error originated, and therefore cannot tell what the code means.
For example, if :symbol:`mongoc_collection_update_one` sets the error's domain to ``MONGOC_ERROR_COLLECTION`` and its code to 24, the application cannot know whether 24 is the generic driver error code ``MONGOC_ERROR_COLLECTION_UPDATE_FAILED`` or the specific server error code "LockTimeout".
To fix this flaw while preserving backward compatibility, the C Driver 1.4 introduces "Error API Versions". Version 1, the default Error API Version, maintains the flawed behavior. Version 2 adds a new error domain, ``MONGOC_ERROR_SERVER``. In Version 2, error codes originating on the server always have error domain ``MONGOC_ERROR_SERVER`` or ``MONGOC_ERROR_WRITE_CONCERN``. When the driver uses Version 2 the application can always determine the origin and meaning of error codes. New applications should use Version 2, and existing applications should be updated to use Version 2 as well.
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| Error Source | API Version 1 | API Version 2 |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| :symbol:`mongoc_cursor_error` | ``MONGOC_ERROR_QUERY`` | ``MONGOC_ERROR_SERVER`` |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| :symbol:`mongoc_client_command_with_opts`, | ``MONGOC_ERROR_QUERY`` | ``MONGOC_ERROR_SERVER`` |
| :symbol:`mongoc_database_command_with_opts`, and | | |
| other command functions | | |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| :symbol:`mongoc_collection_count_with_opts` | ``MONGOC_ERROR_QUERY`` | ``MONGOC_ERROR_SERVER`` |
| :symbol:`mongoc_client_get_database_names_with_opts`,| | |
| and other command helper functions | | |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| :symbol:`mongoc_collection_insert_one` | ``MONGOC_ERROR_COMMAND`` | ``MONGOC_ERROR_SERVER`` |
| :symbol:`mongoc_collection_insert_bulk` | | |
| :symbol:`mongoc_collection_update_one` | | |
| :symbol:`mongoc_collection_update_many` | | |
| :symbol:`mongoc_collection_replace_one` | | |
| :symbol:`mongoc_collection_delete_one` | | |
| :symbol:`mongoc_collection_delete_many` | | |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| :symbol:`mongoc_bulk_operation_execute` | ``MONGOC_ERROR_COMMAND`` | ``MONGOC_ERROR_SERVER`` |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
| Write-concern timeout | ``MONGOC_ERROR_WRITE_CONCERN`` | ``MONGOC_ERROR_WRITE_CONCERN`` |
+------------------------------------------------------+----------------------------------------+----------------------------------------+
The Error API Versions are defined with ``MONGOC_ERROR_API_VERSION_LEGACY`` and ``MONGOC_ERROR_API_VERSION_2``. Set the version with :symbol:`mongoc_client_set_error_api` or :symbol:`mongoc_client_pool_set_error_api`.
See Also
--------
`MongoDB Server Error Codes `_
libmongoc-1.9.2+dfsg/doc/full_index.rst 0000664 0000000 0000000 00000000431 13226174053 0020044 0 ustar 00root root 0000000 0000000 :man_page: mongoc_reference
:orphan:
.. Yes it's confusing: the home page is called "index" so this is "full_index",
and it works by including the complete Table of Contents from the homepage,
i.e., "index".
Index
=====
.. toctree::
:maxdepth: 6
:titlesonly:
index
libmongoc-1.9.2+dfsg/doc/guides.rst 0000664 0000000 0000000 00000000403 13226174053 0017172 0 ustar 00root root 0000000 0000000 :man_page: mongoc_guides
Guides
======
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc-common-task-examples
advanced-connections
connection-pooling
cursors
bulk
aggregate
distinct-mapreduce
visual-studio-guide
create-indexes
libmongoc-1.9.2+dfsg/doc/html/ 0000775 0000000 0000000 00000000000 13226174053 0016127 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/html/Makefile.am 0000664 0000000 0000000 00000001142 13226174053 0020161 0 ustar 00root root 0000000 0000000 SPHINX_HTML_FILES = \
$(wildcard doc/html/*.html) \
$(wildcard doc/html/*.css) \
$(wildcard doc/html/*.js) \
$(wildcard doc/html/*.png) \
$(wildcard doc/html/_static/*.css) \
$(wildcard doc/html/_static/*.js) \
$(wildcard doc/html/_static/*.png) \
doc/html/.nojekyll \
doc/html/objects.inv
CLEANFILES += $(SPHINX_HTML_FILES)
.PHONY: doc/html
doc/html: $(SPHINX_HTML_FILES)
# sphinx-build "-E" is "ignore cache".
$(SPHINX_HTML_FILES):
-mkdir -p doc/html
$(SPHINX_BUILD) -j 8 -qEW $(top_srcdir)/doc doc/html
rm -rf doc/html/.doctrees doc/html/.buildinfo
EXTRA_DIST += doc/html
libmongoc-1.9.2+dfsg/doc/includes/ 0000775 0000000 0000000 00000000000 13226174053 0016771 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/includes/crud-opts.txt 0000664 0000000 0000000 00000002562 13226174053 0021457 0 ustar 00root root 0000000 0000000 ``opts`` may be NULL or a BSON document with additional command options:
* ``readConcern``: Construct a :symbol:`mongoc_read_concern_t` and use :symbol:`mongoc_read_concern_append` to add the read concern to ``opts``. See the example code for :symbol:`mongoc_client_read_command_with_opts`.
* ``writeConcern``: Construct a :symbol:`mongoc_write_concern_t` and use :symbol:`mongoc_write_concern_append` to add the write concern to ``opts``. See the example code for :symbol:`mongoc_client_write_command_with_opts`.
* ``sessionId``: Construct a :symbol:`mongoc_client_session_t` with :symbol:`mongoc_client_start_session` and use :symbol:`mongoc_client_session_append` to add the session to ``opts``. See the example code for :symbol:`mongoc_client_session_t`.
* ``validate``: Set to ``false`` to skip client-side validation of the provided BSON documents.
* ``bypassDocumentValidation``: Set to ``true`` to skip server-side schema validation of the provided BSON documents.
* ``collation``: Configure textual comparisons. See :ref:`Setting Collation Order `, and `the MongoDB Manual entry on Collation `, and `the MongoDB Manual entry on Collation `, and `the MongoDB Manual entry on Collation `_. To disable causal consistency, before starting a session create a :symbol:`mongoc_session_opt_t` with :symbol:`mongoc_session_opts_new()` and call :symbol:`mongoc_session_opts_set_causal_consistency()`, then free the struct with :symbol:`mongoc_session_opts_destroy`.
Unacknowledged writes are not causally consistent. If you execute a write operation with a :symbol:`mongoc_write_concern_t` on which you have called :symbol:`mongoc_write_concern_set_w` with a value of 0, the write does not participate in causal consistency.
.. the timeout warning is mandated by the Driver Sessions Spec
A :symbol:`mongoc_client_session_t` must be used by only one thread at a time. Due to session pooling, :symbol:`mongoc_client_start_session` may return a session that has been idle for some time and is about to be closed after its idle timeout. Use the session within one minute of acquiring it to refresh the session and avoid a timeout.
libmongoc-1.9.2+dfsg/doc/includes/write-opts.txt 0000664 0000000 0000000 00000002230 13226174053 0021644 0 ustar 00root root 0000000 0000000 ``opts`` may be NULL or a BSON document with additional command options:
* ``writeConcern``: Construct a :symbol:`mongoc_write_concern_t` and use :symbol:`mongoc_write_concern_append` to add the write concern to ``opts``. See the example code for :symbol:`mongoc_client_write_command_with_opts`.
* ``sessionId``: Construct a :symbol:`mongoc_client_session_t` with :symbol:`mongoc_client_start_session` and use :symbol:`mongoc_client_session_append` to add the session to ``opts``. See the example code for :symbol:`mongoc_client_session_t`.
* ``collation``: Configure textual comparisons. See :ref:`Setting Collation Order `, and `the MongoDB Manual entry on Collation ` to generate and parse BSON documents, the native data format of MongoDB.
.. toctree::
:maxdepth: 2
installing
.. toctree::
:maxdepth: 2
tutorial
.. toctree::
:maxdepth: 2
authentication
.. toctree::
:maxdepth: 2
basic-troubleshooting
.. toctree::
:maxdepth: 2
guides
.. toctree::
:titlesonly:
:maxdepth: 2
api
.. toctree::
:titlesonly:
:maxdepth: 2
application-performance-monitoring
libmongoc-1.9.2+dfsg/doc/init-cleanup.rst 0000664 0000000 0000000 00000002232 13226174053 0020304 0 ustar 00root root 0000000 0000000 :man_page: mongoc_init_cleanup
Initialization and cleanup
==========================
Synopsis
--------
.. include:: includes/init_cleanup.txt
.. only:: html
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_init
mongoc_cleanup
Deprecated feature: automatic initialization and cleanup
--------------------------------------------------------
On some platforms the driver can automatically call :symbol:`mongoc_init` before ``main``, and call :symbol:`mongoc_cleanup` as the process exits. This is problematic in situations where related libraries also execute cleanup code on shutdown, and it creates inconsistent rules across platforms. Therefore the automatic initialization and cleanup feature is deprecated, and will be dropped in version 2.0. Meanwhile, for backward compatibility, the feature is *enabled* by default on platforms where it is available.
For portable, future-proof code, always call :symbol:`mongoc_init` and :symbol:`mongoc_cleanup` yourself, and configure the driver like:
.. code-block:: none
./configure --disable-automatic-init-and-cleanup
Or with CMake:
.. code-block:: none
cmake -DENABLE_AUTOMATIC_INIT_AND_CLEANUP=NO
libmongoc-1.9.2+dfsg/doc/installing.rst 0000664 0000000 0000000 00000024054 13226174053 0020066 0 ustar 00root root 0000000 0000000 :man_page: mongoc_installing
Installing the MongoDB C Driver
===============================
The following guide will step you through the process of downloading, building, and installing the current release of the MongoDB C Driver.
Supported Platforms
-------------------
The MongoDB C Driver is `continuously tested `_ on variety of platforms including:
- Archlinux
- Debian 8.1
- macOS 10.10
- Microsoft Windows Server 2008
- RHEL 7.0, 7.1, 7.2
- SUSE 12
- Ubuntu 12.04, 14.04, 16.04
- Clang 3.4, 3.5, 3.7, 3.8
- GCC 4.6, 4.8, 4.9, 5.3
- MinGW-W64
- Visual Studio 2010, 2013, 2015
- x86, x86_64, ARM (aarch64), Power8 (ppc64le), zSeries (s390x)
Install with a Package Manager
------------------------------
The libmongoc package is available on recent versions of Debian and Ubuntu.
.. code-block:: none
$ apt-get install libmongoc-1.0-0
On Fedora, a mongo-c-driver package is available in the default repositories and can be installed with:
.. code-block:: none
$ dnf install mongo-c-driver
On recent Red Hat systems, such as CentOS and RHEL 7, a mongo-c-driver package is available in the `EPEL `_ repository. To check version available, see `https://apps.fedoraproject.org/packages/mongo-c-driver `_. The package can be installed with:
.. code-block:: none
$ yum install mongo-c-driver
Building on Unix
----------------
Prerequisites
^^^^^^^^^^^^^
OpenSSL is required for authentication or for SSL connections to MongoDB. Kerberos or LDAP support requires Cyrus SASL.
To install all optional dependencies on RedHat / Fedora:
.. code-block:: none
$ sudo yum install pkg-config openssl-devel cyrus-sasl-devel
On Debian / Ubuntu:
.. code-block:: none
$ sudo apt-get install pkg-config libssl-dev libsasl2-dev
On FreeBSD:
.. code-block:: none
$ su -c 'pkg install pkgconf openssl cyrus-sasl'
Building from a release tarball
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Unless you intend on contributing to the mongo-c-driver, you will want to build from a release tarball.
The most recent release of libmongoc is |release| and can be :release:`downloaded here <>`. The following snippet will download and extract the driver, and configure it:
.. parsed-literal::
$ wget |release_download|
$ tar xzf mongo-c-driver-|release|.tar.gz
$ cd mongo-c-driver-|release|
$ ./configure --disable-automatic-init-and-cleanup
The ``--disable-automatic-init-and-cleanup`` option is recommended, see :doc:`init-cleanup`. For a list of all configure options, run ``./configure --help``.
If ``configure`` completed successfully, you'll see something like the following describing your build configuration.
.. parsed-literal::
libmongoc |release| was configured with the following options:
Build configuration:
Enable debugging (slow) : no
Compile with debug symbols (slow) : no
Enable GCC build optimization : yes
Enable automatic init and cleanup : no
Enable maintainer flags : no
Code coverage support : no
Cross Compiling : no
Fast counters : no
Shared memory performance counters : yes
SASL : sasl2
SSL : openssl
Snappy Compression : no
Zlib Compression : bundled
Libbson : bundled
Documentation:
man : no
HTML : no
mongo-c-driver contains a copy of libbson, in case your system does not already have libbson installed. The configure script will detect if libbson is not installed and use the bundled libbson.
.. code-block:: none
$ make
$ sudo make install
Building from git
^^^^^^^^^^^^^^^^^
To build an unreleased version of the driver from git requires additional dependencies.
RedHat / Fedora:
.. code-block:: none
$ sudo yum install git gcc automake autoconf libtool
Debian / Ubuntu:
.. code-block:: none
$ sudo apt-get install git gcc automake autoconf libtool
FreeBSD:
.. code-block:: none
$ su -c 'pkg install git gcc automake autoconf libtool'
Once you have the dependencies installed, clone the repository and build the current master or a particular release tag:
.. code-block:: none
$ git clone https://github.com/mongodb/mongo-c-driver.git
$ cd mongo-c-driver
$ git checkout x.y.z # To build a particular release
$ ./autogen.sh --with-libbson=bundled
$ make
$ sudo make install
Generating the documentation
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Install `Sphinx € mnÝ~v§¿žÆvøvonÝŸ.îÚï¿ÿô~ÿ‹=ÛÉÝ çqhÌíf‡Sc¦É<Á f&“ÿðGÎiŽö¾6i)Da&S$û¿¶¹þ/êÿ"Ìc7˜I½ìärZÒ)j {ä=ãUiÇ“Õ Áã
æ±s—fnÇÛ&„Éh@J9g×]U~
àäjQæñ6vƒ³“Ê,³X”iÛîjúo¿{«Bk„@ ÅŽírµƒS¡ÙÙQ€ÛcGépqUscÁ˜
< J§q9özgˆ® :AùÛøçï4R49(ÊœóæõçÍk‘óæ5ålôÈNìŒ ï‡Wóõ‹U§šärPÒ)ª¶PÑPQ'¨a|l×j¬lsX6(méÕ90xÇ«2vjçôGx‘&{o¿jŒhrJ” g~º õI=¹œ”t‚
“]£NÉ娤 ¨Ù™ëm‹d`´æƒé·ˆÞ–yÞ ´e8Ùs7Xõ>Ö N¬eº³:O y•@|UuŠŠ&ÇD¹ræÆ~u^¶§æ³8‹@ ± SCqLl/¶ýÒ<Øiî„täÒ+j¼ÞÌÄ›&ë0=)kâÐ'ä¥d9ßþé:»i|’Ò¡9СÀ{¬³Yz§BAŒ .…öQ…zO€y•BôzåÚ JüMj—nŒhÛSãF1Åë$Ë+$Ñ÷Ͷ_NÝp¯!Ö[½»øe‚à̯XTÄBX—^Íy¯¿áRíä0@–„RÜß hŒ/¨Y
’ëUíµVòÀà‚ „ü3/Ûæt ÂqÀ,dûÿE€EäÇß5ešÆIhÖ¬£=O–O?Aðð³°ã85ΰœb€¼"ÁÜ«ùìë Mž,‚Ї°];ÛXA±ÐÃØá¹Ú† ”ÚŽÃèÆ¡kå Ià»'ß3®û û±ý²Â¶j'׋ÔèâŸoçÎö|ÙP ¨ZIwµ ‚¤ðƧA|üb›0VÑüÒÊuŒJ å$µBü¶A9‰Y-ˆ¨"&Ìòi4eFçE“·PÈHhEå xƒY’¤^”tEìrÄÕêÐtx°R…GùD…øê¡DY?AÁ6űӓ¤ªg'Øf4zn’TýÔ„øŒÇNL’¬— —ÁÈYIÅ“àq ÑæFŸ#Az¼ "Oë‘$h“OzédÛeÒw6)/Ë„#
®g€Á¨(ÇÀ£ |%eÔàÍP’ä#CàÑâðqa•äÃBlK(tPXU阚 &íI[D‡žÈÂInKÏlö¼–OW‹Ð `RºÙÏì¦WZ¢ÚŒTŒBû ÷Üþáà»›9ÅYúÞ·;Ã*q€¯D¨I‡YRÐVàx+zYÖ/„JÇ®WëWy»¶^NÏèóé9p‰Ó (ÛuÂD¯F>[X·Nø0 ü³YJøG‡$¦Ûâ9Ì?íú‘ï…“ ÊMB)-ýz¥¤½by¯jâé/ùÄžçV ¦WüJ°›/"!Y„DH×ÇÅ Ùpu ~ˉ¤YíÕ·÷ìÆÉ6ÎHk Ëefwæp*£SW›WÐFaßä”ý!…|0ƒ¹·a——2¥ŽG5Éu —óYØû C À⢠¹ .ô«(ž/!WBÁÓ%¿VßÑ `€Š!Âk…b°ôõõBø-Ÿ W‡d£“à „?eMƒmZ
H»aœƒ‚sÅ1Z ’ Çhù½ÑAxˆÀã];Êû)H¥ã÷ Õ›ým ß~éð!‘‹‡°sX û9hRX–!G¾#xò‹Ê¸Õ>Ò‹¤—"ŸY«¨Ëy…‚Õæ¼ pAbº@úpû˜Äk(NI/Xól.wô•Î‹9Ϭo¶–6Ô»˜áô‚RØF)€”"®äe“°bÒ3=„HÝÀ?§íF®7¥Šx™Ôd¶u:
Iã8FÕkÚ*¥ÉET›ðÕÆ›ÏYaƒ<^vPA‘â6ë8.aóϦu_µäàq@P)DkÈj’ mIFÂÇZè2ÓƒÕ–PØFhZ¸ñ/U0ªVÓ»ßìI\V¦¦7?Ë»3ÏÎLÎRÍ_—Ó7ä襸 áܸÎWV %N‹˜íeœéœÕh×
]ÆhèUña›õ Á 8-½ÝŸ$R¶0%‹€Þó?HùÑÀÙQ¹þ¯í‘‹)«.¢švÖ´®ie ÞÚ,HE³–Þ2tíÅLÏ£Ô²OŠ?Õ ÇÁ7²$Žðjq ãIqZ>~qZÂhjÅ‹ÏK.(~h…]TÖ1 (0Qëì íCo1Ñë$Ñ+5q9†ÃS©©ŠƒÚŠÇ_† ¤%¾(ØX¬Ó pÔ*W“{£Pêà:¸óÛÆÎñµ;û)F܆KA°.‚]뼸ˆÔF‹ dè!lØôêÈâR\Ñ*¼|Û`U›Âªhqß&#äRVÑ J¥ !w±òAÆjáü,b‚¶õC.ã_Áý1žþ‹ ÄUÇ«‹™a5ó@—3ñ…Ú¤üwh” Gk.lsi°¬JÏçÕâðdÎJèë~ª»w
´FpÞê¬ô\Z-Ï¥¬Lcß MûEß³ŠC€N#áîò›FùÙ\ PdÕ|aa›6~»þÿBzìMãâºÁ¢Ïw7üDz÷!û»4ùÿ’Cvߺ8ò8(ZÎ/fÿÃÝÇŸ÷?å/€|ê8χ[oœŸ‡¯‡at¤n‚_ÞÙÊÎþçàì|‡êÌàë„ «šRßÕß»¸LÅÁQIÿÇ¡Ú;/}ßtà ¿r^Õ”õ>ü¹»·ÃÙ›£íClQQäÒðU'%Åü=þ½c¥Ì¿»c¸û>fv~IîĪ–BkTÏý¶¯ëÃßM辌ñqÆW@p߬¿%÷0‡’ûCÖöþ)ýÁ´ûwûÿÁòæåv'ç÷{å&¿¼¼š{XsïŠV»Æ¼£K„u5ðOßw×ñ$Ü©ÛÓ¡ùÅÆxZz›ïùÔ¥~àòñøÙ¶îýOóîf¦™Ü‰,¥ÈOÙê½ Yi| Ñá!v
—`ÈÙ.3 Ä¥‘ BÊÿ“íãë˜ðÑO½Ëä’ ö "ä!©·{ÿ}ü¶õ]²öÿ²Oõ®ïfk¦ö‚‹IZþè8ùŸÌ½Ý…]£¹ÆŽDnvrfÑb›íÜ%œö¯bJùµüܹÅ?˜;|.P´ ›íèg ëÇÿùõo‡·;áiô]t œûÿ&1”þ;¶ @ libmongoc-1.9.2+dfsg/doc/lifecycle.rst 0000664 0000000 0000000 00000004164 13226174053 0017661 0 ustar 00root root 0000000 0000000 Object Lifecycle
================
This page documents the order of creation and destruction for libmongoc's main struct types.
Clients and pools
-----------------
Call :symbol:`mongoc_init()` once, before calling any other libmongoc functions, and call :symbol:`mongoc_cleanup()` once before your program exits.
A program that uses libmongoc from multiple threads should create a :symbol:`mongoc_client_pool_t` with :symbol:`mongoc_client_pool_new()`. Each thread acquires a :symbol:`mongoc_client_t` from the pool with :symbol:`mongoc_client_pool_pop()` and returns it with :symbol:`mongoc_client_pool_push()` when the thread is finished using it. To destroy the pool, first return all clients, then call :symbol:`mongoc_client_pool_destroy()`.
If your program uses libmongoc from only one thread, create a :symbol:`mongoc_client_t` directly with :symbol:`mongoc_client_new()` or :symbol:`mongoc_client_new_from_uri()`. Destroy it with :symbol:`mongoc_client_destroy()`.
Databases, collections, and related objects
-------------------------------------------
You can create a :symbol:`mongoc_database_t` or :symbol:`mongoc_collection_t` from a :symbol:`mongoc_client_t`, and create a :symbol:`mongoc_cursor_t` or :symbol:`mongoc_bulk_operation_t` from a :symbol:`mongoc_collection_t`.
Each of these objects must be destroyed before the client they were created from, but their lifetimes are otherwise independent.
GridFS objects
--------------
You can create a :symbol:`mongoc_gridfs_t` from a :symbol:`mongoc_client_t`, create a :symbol:`mongoc_gridfs_file_t` or :symbol:`mongoc_gridfs_file_list_t` from a :symbol:`mongoc_gridfs_t`, create a :symbol:`mongoc_gridfs_file_t` from a :symbol:`mongoc_gridfs_file_list_t`, and create a :symbol:`mongoc_stream_t` from a :symbol:`mongoc_gridfs_file_t`.
Each of these objects depends on the object it was created from. Always destroy GridFS objects in the reverse of the order they were created. The sole exception is that a :symbol:`mongoc_gridfs_file_t` need not be destroyed before the :symbol:`mongoc_gridfs_file_list_t` it was created from.
Sessions
--------
.. include:: includes/session-lifecycle.txt
libmongoc-1.9.2+dfsg/doc/logging.rst 0000664 0000000 0000000 00000007266 13226174053 0017356 0 ustar 00root root 0000000 0000000 :man_page: mongoc_logging
Logging
=======
MongoDB C driver Logging Abstraction
Synopsis
--------
.. code-block:: c
typedef enum {
MONGOC_LOG_LEVEL_ERROR,
MONGOC_LOG_LEVEL_CRITICAL,
MONGOC_LOG_LEVEL_WARNING,
MONGOC_LOG_LEVEL_MESSAGE,
MONGOC_LOG_LEVEL_INFO,
MONGOC_LOG_LEVEL_DEBUG,
MONGOC_LOG_LEVEL_TRACE,
} mongoc_log_level_t;
#define MONGOC_ERROR(...)
#define MONGOC_CRITICAL(...)
#define MONGOC_WARNING(...)
#define MONGOC_MESSAGE(...)
#define MONGOC_INFO(...)
#define MONGOC_DEBUG(...)
typedef void (*mongoc_log_func_t) (mongoc_log_level_t log_level,
const char *log_domain,
const char *message,
void *user_data);
void
mongoc_log_set_handler (mongoc_log_func_t log_func, void *user_data);
void
mongoc_log (mongoc_log_level_t log_level,
const char *log_domain,
const char *format,
...) BSON_GNUC_PRINTF (3, 4);
const char *
mongoc_log_level_str (mongoc_log_level_t log_level);
void
mongoc_log_default_handler (mongoc_log_level_t log_level,
const char *log_domain,
const char *message,
void *user_data);
void
mongoc_log_trace_enable (void);
void
mongoc_log_trace_disable (void);
The MongoDB C driver comes with an abstraction for logging that you can use in your application, or integrate with an existing logging system.
Macros
------
To make logging a little less painful, various helper macros are provided. See the following example.
.. code-block:: c
#undef MONGOC_LOG_DOMAIN
#define MONGOC_LOG_DOMAIN "my-custom-domain"
MONGOC_WARNING ("An error occurred: %s", strerror (errno));
Custom Log Handlers
-------------------
The default log handler prints a timestamp and the log message to ``stdout``, or to ``stderr`` for warnings, critical messages, and errors.
You can override the handler with ``mongoc_log_set_handler()``.
Your handler function is called in a mutex for thread safety.
For example, you could register a custom handler to suppress messages at INFO level and below:
.. code-block:: c
void
my_logger (mongoc_log_level_t log_level,
const char *log_domain,
const char *message,
void *user_data)
{
/* smaller values are more important */
if (log_level < MONGOC_LOG_LEVEL_INFO) {
mongoc_log_default_handler (log_level, log_domain, message, user_data);
}
}
int
main (int argc, char *argv[])
{
mongoc_init ();
mongoc_log_set_handler (my_logger, NULL);
/* ... your code ... */
mongoc_cleanup ();
return 0;
}
To restore the default handler:
.. code-block:: c
mongoc_log_set_handler (mongoc_log_default_handler, NULL);
Disable logging
---------------
To disable all logging, including warnings, critical messages and errors, provide an empty log handler:
.. code-block:: c
mongoc_log_set_handler (NULL, NULL);
Tracing
-------
If compiling your own copy of the MongoDB C driver, consider configuring with ``--enable-tracing`` to enable function tracing and hex dumps of network packets to ``STDERR`` and ``STDOUT`` during development and debugging.
This is especially useful when debugging what may be going on internally in the driver.
Trace messages can be enabled and disabled by calling ``mongoc_log_trace_enable()`` and ``mongoc_log_trace_disable()``
.. note::
Compiling the driver with ``--enable-tracing`` will affect its performance. Disabling tracing with ``mongoc_log_trace_disable()`` significantly reduces the overhead, but cannot remove it completely.
libmongoc-1.9.2+dfsg/doc/man/ 0000775 0000000 0000000 00000000000 13226174053 0015736 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/man/Makefile.am 0000664 0000000 0000000 00000000535 13226174053 0017775 0 ustar 00root root 0000000 0000000 CLEANFILES += $(wildcard doc/man/*.3)
.PHONY: doc/man
dist_man_MANS = $(wildcard doc/man/*.3)
man3_MANS = $(wildcard doc/man/*.3)
# sphinx-build "-E" is "ignore cache", "b" is build type.
doc/man:
-mkdir -p doc/man
$(SPHINX_BUILD) -qEW -j 8 -b man $(top_srcdir)/doc doc/man
rm -rf doc/man/.doctrees doc/man/.buildinfo
EXTRA_DIST += doc/man
libmongoc-1.9.2+dfsg/doc/matcher.rst 0000664 0000000 0000000 00000002745 13226174053 0017350 0 ustar 00root root 0000000 0000000 :man_page: mongoc_matcher
:orphan:
Client Side Document Matching
=============================
Basic Document Matching (Deprecated)
------------------------------------
.. warning::
This feature will be removed in version 2.0.
The MongoDB C driver supports matching a subset of the MongoDB query specification on the client.
Currently, basic numeric, string, subdocument, and array equality, ``$gt``, ``$gte``, ``$lt``, ``$lte``, ``$in``, ``$nin``, ``$ne``, ``$exists``, ``$type``, ``$and``, and ``$or`` are supported. As this is not the same implementation as the MongoDB server, some inconsistencies may occur. Please file a bug if you find such a case.
The following example performs a basic query against a BSON document.
.. literalinclude:: ../examples/example-matcher.c
:language: c
:caption: example-matcher.c
The following example shows how to process a BSON stream from ``stdin`` and match it against a query. This can be useful if you need to perform simple matching against ``mongodump`` backups.
.. literalinclude:: ../examples/filter-bsondump.c
:language: c
:caption: filter-bsondump.c
To test this, perform a ``mongodump`` of a single collection and pipe it to the program.
.. code-block:: none
$ echo "db.test.insert({hello:'world'})" | mongo
MongoDB shell version: 2.6.1
connecting to: test
WriteResult({ "nInserted" : 1 })
bye
$ mongodump -d test -c test -o - | filter-bsondump
{ "_id" : { "$oid" : "537afac9a70e5b4d556153bc" }, "hello" : "world" }
libmongoc-1.9.2+dfsg/doc/mongoc-common-task-examples.rst 0000664 0000000 0000000 00000006756 13226174053 0023257 0 ustar 00root root 0000000 0000000 :man_page: mongoc_common_task_examples
Common Tasks
============
Drivers for some other languages provide helper functions to perform certain common tasks. In the C Driver we must explicitly build commands to send to the server.
This snippet contains example code for the ``explain``, ``copydb`` and ``cloneCollection`` commands.
Setup
-----
First we'll write some code to insert sample data:
.. literalinclude:: ../examples/doc-common-insert.c
:language: c
:caption: doc-common-insert.c
"explain" Command
-----------------
This is how to use the ``explain`` command in MongoDB 3.2+:
.. literalinclude:: ../examples/common_operations/explain.c
:language: c
:caption: explain.c
.. _mongoc-common-task-examples_copydb:
"copydb" Command
----------------
This example requires two instances of mongo to be running.
Here's how to use the ``copydb`` command to copy a database from another instance of MongoDB:
.. literalinclude:: ../examples/common_operations/copydb.c
:language: c
:caption: copydb.c
.. _mongoc-common-task-examples_clone_collection:
"cloneCollection" Command
-------------------------
This example requires two instances of mongo to be running.
Here's an example of the ``cloneCollection`` command to clone a collection from another instance of MongoDB:
.. literalinclude:: ../examples/common_operations/clone-collection.c
:language: c
:caption: clone-collection.c
Running the Examples
--------------------
.. literalinclude:: ../examples/common_operations/common-operations.c
:language: c
:caption: common-operations.c
First launch two separate instances of mongod (must be done from separate shells):
.. code-block:: none
$ mongod
.. code-block:: none
$ mkdir /tmp/db2$ mongod --dbpath /tmp/db2 --port 27018 # second instance
Now compile and run the example program:
.. code-block:: none
$ cd examples/common_operations/$ gcc -Wall -o example common-operations.c $(pkg-config --cflags --libs libmongoc-1.0)$ ./example localhost:27017 localhost:27018
Inserting data
explain
{
"executionStats" : {
"allPlansExecution" : [],
"executionStages" : {
"advanced" : 19,
"direction" : "forward" ,
"docsExamined" : 76,
"executionTimeMillisEstimate" : 0,
"filter" : {
"x" : {
"$eq" : 1
}
},
"invalidates" : 0,
"isEOF" : 1,
"nReturned" : 19,
"needTime" : 58,
"needYield" : 0,
"restoreState" : 0,
"saveState" : 0,
"stage" : "COLLSCAN" ,
"works" : 78
},
"executionSuccess" : true,
"executionTimeMillis" : 0,
"nReturned" : 19,
"totalDocsExamined" : 76,
"totalKeysExamined" : 0
},
"ok" : 1,
"queryPlanner" : {
"indexFilterSet" : false,
"namespace" : "test.things",
"parsedQuery" : {
"x" : {
"$eq" : 1
}
},
"plannerVersion" : 1,
"rejectedPlans" : [],
"winningPlan" : {
"direction" : "forward" ,
"filter" : {
"x" : {
"$eq" : 1
}
},
"stage" : "COLLSCAN"
}
},
"serverInfo" : {
"gitVersion" : "05552b562c7a0b3143a729aaa0838e558dc49b25" ,
"host" : "MacBook-Pro-57.local",
"port" : 27017,
"version" : "3.2.6"
}
}
copydb
{ "ok" : 1 }
clone collection
{ "ok" : 1 }
libmongoc-1.9.2+dfsg/doc/mongoc-theme/ 0000775 0000000 0000000 00000000000 13226174053 0017545 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/mongoc-theme/globaltoc.html 0000664 0000000 0000000 00000000377 13226174053 0022410 0 ustar 00root root 0000000 0000000 {{ shorttitle }}
{{ toctree(titles_only=True, maxdepth=2) }}
libmongoc-1.9.2+dfsg/doc/mongoc-theme/layout.html 0000664 0000000 0000000 00000003420 13226174053 0021747 0 ustar 00root root 0000000 0000000 {%- extends "basic/layout.html" %}
{%- block extrahead %}
{{ super() }}
{% endblock %}
{# remove related docs bars #}
{%- block relbar1 %}{% endblock %}
{%- block relbar2 %}{% endblock %}
{%- block document %}
{% if pagename != 'index' %}
{% endif %}
{% block body %} {% endblock %}
{%- endblock %}
{% block footer %}
Created using Sphinx {{ sphinx_version }}, based on Sphinx Readable Theme.
{% endblock %}
libmongoc-1.9.2+dfsg/doc/mongoc-theme/static/ 0000775 0000000 0000000 00000000000 13226174053 0021034 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/mongoc-theme/static/mongoc.css_t 0000664 0000000 0000000 00000024044 13226174053 0023357 0 ustar 00root root 0000000 0000000 /*
* mongoc.css_t
* ~~~~~~~~~~~~~~
*
* Sphinx stylesheet -- MongoDB C Driver theme.
*
* Adapted from Sphinx Readable Theme, Copyright 2013 by Ignacy Sokolowski
* https://github.com/ignacysokolowski/sphinx-readable-theme
*
* Copyright (c) 2017 MongoDB, Inc.
*
* MIT LICENSE
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
{% set page_width = '90%' %}
@import url('basic.css');
/* -- page layout --------------------------------------------------------- */
body {
font-family: sans-serif;
font-size: 18px;
margin: 0;
padding: 0;
}
div.document {
margin: 10px auto 0 auto;
max-width: {{ page_width }};
}
div.documentwrapper {
float: left;
width: 100%;
}
div.bodywrapper {
margin: 0 0 0 {{ theme_sidebarwidth|toint }}px;
}
/* make room for the big table */
div.bodywrapper#errors {
margin: 0;
}
div.body {
background-color: #ffffff;
color: #3e4349;
padding: 0 30px 30px 30px;
}
div.footer {
color: #555;
font-size: 14px;
margin: 20px auto 30px auto;
padding: 1em;
max-width: 880px;
}
div.footer a {
text-decoration: underline;
}
div.related {
padding: 10px 0;
width: auto;
}
/* on wide windows, show the sidebar and hide the home link */
div.related li.nav-item-0 {
display: none;
}
div.related ul {
padding: 0;
padding-left: 0 !important;
margin: 0 !important;
}
div.sphinxsidebar {
float: left;
font-size: 14px;
line-height: 1.5em;
margin-left: -100%;
width: {{ theme_sidebarwidth|toint }}px;
}
div.sphinxsidebarwrapper {
font-size: 14px;
line-height: 1.5em;
padding: 10px 0;
}
div.sphinxsidebar h3,
div.sphinxsidebar h4 {
color: #333;
font-size: 24px;
font-weight: normal;
margin: 0 0 5px 0;
padding: 0;
}
div.sphinxsidebarwrapper h3:first-of-type {
margin-bottom: 44px;
}
div.sphinxsidebar h4 {
font-size: 1.1em;
}
div.sphinxsidebar h3 a {
color: #333;
}
div.sphinxsidebar p {
color: #888;
}
div.sphinxsidebar p.searchtip {
line-height: 1.4em;
}
div.sphinxsidebar ul {
color: #000;
margin: 10px 0 20px;
padding: 0;
}
div.sphinxsidebar ul li.current > a {
font-weight: bold;
}
div.sphinxsidebar a {
color: #444;
}
div.sphinxsidebar a:hover {
color: #d00;
}
div.sphinxsidebar input {
border: 1px solid #ccc;
font-family: sans-serif;
font-size: 1em;
}
div.footer-nav {
clear: both;
}
div.footer a.footer-nav-button {
display: block;
font-size: 18px;
margin: 0.5em 0;
text-decoration: none;
}
a.footer-nav-button-prev {
float: left;
}
a.footer-nav-button-next {
float: right;
}
div.colophon {
clear: both;
text-align: center;
padding: 2em;
}
/* -- body styles --------------------------------------------------------- */
a {
color: #900;
text-decoration: none;
}
a:visited {
color: #700;
}
a:hover {
color: #d00;
text-decoration: underline;
}
hr {
border: 1px solid #b1b4b6;
}
div.body h1,
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 { font-weight: normal; }
div.body h1,
div.body h2,
div.body h3,
div.body h4 { color: #212224; }
div.body h5 { color: #000; }
div.body h6 { color: #777; }
div.body h1 { margin: 0 0 10px 0; }
div.body h2,
div.body h3 { margin: 30px 0px 10px 0px; }
div.body h4,
div.body h5,
div.body h6 { margin: 20px 0px 10px 0px; }
div.body h1 { padding: 0 0 10px 0; }
div.body h2,
div.body h3 { padding: 10px 0 10px 0; }
div.body h4 { padding: 10px 0 10px 0; }
div.body h5,
div.body h6 { padding: 10px 0 0 0; }
div.body h1,
div.body h2,
div.body h3 { border-bottom: 1px solid #ddd; }
div.body h4 { border-bottom: 1px solid #e5e5e5; }
div.body h1 { font-size: 230%; }
div.body h2 { font-size: 180%; }
div.body h3 { font-size: 130%; }
div.body h4 { font-size: 110%; }
div.body h5 { font-size: 105%; }
div.body h6 { font-size: 100%; }
a.headerlink {
color: #c60f0f;
font-size: 0.8em;
padding: 0 4px 0 4px;
text-decoration: none;
}
a.headerlink:hover {
background-color: #c60f0f;
color: #fff;
}
div.body ul {
list-style: disc;
margin: 1em 0;
padding-left: 1.3em;
}
div.body ul ul, div.body ol ul {
margin: .2em 0;
padding-left: 1.2em;
}
div.body ul li {
padding: 2px 0;
}
div.body ul.search li {
padding: 5px 0 5px 20px;
}
div.body ol {
counter-reset: li;
margin-left: 0;
padding-left: 0;
}
div.body ol ol {
margin: .2em 0;
}
div.body ol > li {
list-style: none;
margin: 0 0 0 1.9em;
padding: 2px 1px;
position: relative;
}
div.body ol > li:before {
content: counter(li) ".";
counter-increment: li;
top: -2px;
left: -1.9em;
width: 1.9em;
padding: 4px 0;
position: absolute;
text-align: left;
}
div.body p,
div.body dd,
div.body li {
line-height: 1.4em;
}
div.body p, div.body dd, div.body li,
div.body blockquote {
hyphens: none;
text-align: justify;
}
div.admonition p.admonition-title + p {
display: inline;
}
div.highlight {
background-color: #fff;
}
div.important, div.note {
background-color: #eee;
border: 1px solid #ccc;
}
div.attention, div.caution, div.hint, div.seealso, div.tip {
background-color: #fef9e9;
border: 1px solid #fbe091;
}
div.topic {
background-color: #eee;
}
div.danger, div.error, div.warning {
background-color: #ffe4e4;
border: 1px solid #f66;
}
div.literal-block-wrapper {
padding: 0;
}
span.caption-text {
font-family: monospace;
font-size: 0.75em;
}
p.admonition-title {
display: inline;
}
p.admonition-title:after {
content: ':';
}
pre {
background-color: #f5f5f5;
border: 1px solid #C6C9CB;
color: #222;
font-size: 0.75em;
line-height: 1.5em;
margin: 1.5em 0 1.5em 0;
padding: 10px;
box-shadow: 1px 1px 1px #d8d8d8;
-webkit-box-shadow: 1px 1px 1px #d8d8d8;
-moz-box-shadow: 1px 1px 1px #d8d8d8;
}
pre, tt, code {
font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
}
tt, code {
background-color: #ecf0f3;
font-size: 0.85em;
}
tt.descname, code.descname {
font-size: 0.95em;
}
tt.xref, a tt, code.xref, a code {
font-weight: normal;
}
span.pre {
padding: 0 2px;
}
/* Table-of-contents lists (UL) on home page should look like section headers */
{% set toc_selector = 'div.bodywrapper#index div.toctree-wrapper > ul' %}
{{ toc_selector }} {
margin: 0;
}
{{ toc_selector }} {
padding: 0;
margin: 20px 0 0 0;
}
{{ toc_selector }} > li.toctree-l1 {
list-style: none;
margin: 20px 0 10px;
}
{{ toc_selector }} li.toctree-l1 > a {
width: 100%;
display: block;
padding: 17px 0;
margin-bottom: 17px;
border-bottom: 1px solid #ddd;
font-size: 180%;
font-weight: normal;
color: black;
}
{{ toc_selector }} li.toctree-l1 > a:hover {
text-decoration: none;
color: #d00;
}
{{ toc_selector }} li.toctree-l1 ul {
padding-left: 20px;
}
dl.class, dl.function {
margin-bottom: 50px;
}
dl.function > dt,
dl.attribute > dt,
dl.classmethod > dt,
dl.method > dt,
dl.class > dt,
dl.exception > dt {
background-color: #f5f5f5;
margin: 25px 0 10px 0;
padding: 1px 10px;
}
table.docutils {
width: 100%;
}
table.docutils.footnote {
width: auto;
}
table.docutils thead,
table.docutils tfoot {
background: #f5f5f5;
}
table.docutils thead tr th {
color: #000;
font-weight: normal;
padding: 7px 5px;
vertical-align: middle;
}
table.docutils tbody tr th,
table.docutils tbody tr td {
border-bottom: 0;
border-top: solid 1px #ddd;
padding: 7px 5px;
vertical-align: top;
}
table.docutils tbody tr:last-child th,
table.docutils tbody tr:last-child td {
border-bottom: solid 1px #ddd;
}
table.docutils thead tr td p,
table.docutils tfoot tr td p,
table.docutils tbody tr td p,
table.docutils thead tr td ul,
table.docutils tfoot tr td ul,
table.docutils tbody tr td ul,
table.docutils thead tr td ol,
table.docutils tfoot tr td ol,
table.docutils tbody tr td ol {
margin: 0 0 .5em;
}
table.docutils thead tr td p.last,
table.docutils tfoot tr td p.last,
table.docutils tbody tr td p.last,
table.docutils thead tr td ul.last,
table.docutils tfoot tr td ul.last,
table.docutils tbody tr td ul.last,
table.docutils thead tr td ol.last,
table.docutils tfoot tr td ol.last,
table.docutils tbody tr td ol.last {
margin-bottom: 0;
}
.viewcode-back {
font-family: Arial, sans-serif;
}
div.viewcode-block:target {
background-color: #fef9e9;
border-top: 1px solid #fbe091;
border-bottom: 1px solid #fbe091;
}
a.symbol > span {
font-family: monospace;
font-size: 0.85em;
}
div.code-block-caption {
font-size: inherit;
padding: 0 0 1em 0;
}
@media screen and (max-width: 870px) {
div.document {
width: auto;
margin: 0;
}
div.bodywrapper {
margin: 0;
}
div.body {
min-height: 0;
padding: 0 20px 30px 20px;
}
/* hide side bar and reveal home page link */
div.sphinxsidebar, div.colophon {
display: none;
}
div.related li.nav-item-0 {
display: inline;
}
}
libmongoc-1.9.2+dfsg/doc/mongoc-theme/static/pygments.css 0000664 0000000 0000000 00000010305 13226174053 0023413 0 ustar 00root root 0000000 0000000 .highlight .hll { background-color: #ffffcc }
.highlight { background: #f8f8f8; }
.highlight .c { color: #888 } /* Comment */
.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
.highlight .g { color: #000000 } /* Generic */
.highlight .k { color: #004461; font-weight: bold } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #000000 } /* Name */
.highlight .o { color: #582800 } /* Operator */
.highlight .x { color: #000000 } /* Other */
.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #8f5902 } /* Comment.Preproc */
.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
.highlight .gd { color: #a40000 } /* Generic.Deleted */
.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
.highlight .gr { color: #ef2929 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #745334 } /* Generic.Prompt */
.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
.highlight .kc { color: #004461; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #004461; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #004461; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #004461; font-weight: bold } /* Keyword.Pseudo */
.highlight .kr { color: #004461; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #004461; font-weight: bold } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #990000 } /* Literal.Number */
.highlight .s { color: #3b7c03 } /* Literal.String */
.highlight .na { color: #c4a000 } /* Name.Attribute */
.highlight .nb { color: #004461 } /* Name.Builtin */
.highlight .nc { color: #000000 } /* Name.Class */
.highlight .no { color: #000000 } /* Name.Constant */
.highlight .nd { color: #888888 } /* Name.Decorator */
.highlight .ni { color: #ce5c00 } /* Name.Entity */
.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #000000 } /* Name.Function */
.highlight .nl { color: #f57900 } /* Name.Label */
.highlight .nn { color: #000000 } /* Name.Namespace */
.highlight .nx { color: #000000 } /* Name.Other */
.highlight .py { color: #000000 } /* Name.Property */
.highlight .nt { color: #004461; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #000000 } /* Name.Variable */
.highlight .ow { color: #004461; font-weight: bold } /* Operator.Word */
.highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
.highlight .mf { color: #990000 } /* Literal.Number.Float */
.highlight .mh { color: #990000 } /* Literal.Number.Hex */
.highlight .mi { color: #990000 } /* Literal.Number.Integer */
.highlight .mo { color: #990000 } /* Literal.Number.Oct */
.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
.highlight .sd { color: #8f5902 } /* Literal.String.Doc */
.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #000000 } /* Name.Variable.Class */
.highlight .vg { color: #000000 } /* Name.Variable.Global */
.highlight .vi { color: #000000 } /* Name.Variable.Instance */
.highlight .il { color: #990000 } /* Literal.Number.Integer.Long */
libmongoc-1.9.2+dfsg/doc/mongoc-theme/theme.conf 0000664 0000000 0000000 00000000110 13226174053 0021506 0 ustar 00root root 0000000 0000000 [theme]
inherit = basic
stylesheet = mongoc.css
pygments_style = sphinx
libmongoc-1.9.2+dfsg/doc/mongoc/ 0000775 0000000 0000000 00000000000 13226174053 0016445 5 ustar 00root root 0000000 0000000 libmongoc-1.9.2+dfsg/doc/mongoc/__init__.py 0000664 0000000 0000000 00000003143 13226174053 0020557 0 ustar 00root root 0000000 0000000 from docutils.nodes import literal, Text
from docutils.parsers.rst import roles
from sphinx.roles import XRefRole
from sphinx import version_info as sphinx_version_info
class SymbolRole(XRefRole):
def __call__(self, *args, **kwargs):
nodes, messages = XRefRole.__call__(self, *args, **kwargs)
for node in nodes:
attrs = node.attributes
target = attrs['reftarget']
parens = ''
if target.endswith('()'):
# Function call, :symbol:`mongoc_init()`
target = target[:-2]
parens = '()'
if ':' in target:
# E.g., 'bson:bson_t' has domain 'bson', target 'bson_t'
attrs['domain'], name = target.split(':', 1)
attrs['reftarget'] = name
old = node.children[0].children[0]
assert isinstance(old, Text)
new = Text(name + parens, name + parens)
# Ensure setup_child is called.
node.children[0].replace(old, new)
else:
attrs['reftarget'] = target
attrs['reftype'] = 'doc'
attrs['classes'].append('symbol')
if sphinx_version_info >= (1, 6):
# https://github.com/sphinx-doc/sphinx/issues/3698
attrs['refdomain'] = 'std'
return nodes, messages
def setup(app):
roles.register_local_role(
'symbol', SymbolRole(warn_dangling=True, innernodeclass=literal))
return {
'version': '1.0',
'parallel_read_safe': True,
'parallel_write_safe': True,
}
libmongoc-1.9.2+dfsg/doc/mongoc_apm_callbacks_destroy.rst 0000664 0000000 0000000 00000000567 13226174053 0023614 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_callbacks_destroy
mongoc_apm_callbacks_destroy()
==============================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_callbacks_destroy (mongoc_apm_callbacks_t *callbacks);
Free a :symbol:`mongoc_apm_callbacks_t`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_callbacks_new.rst 0000664 0000000 0000000 00000000731 13226174053 0022705 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_callbacks_new
mongoc_apm_callbacks_new()
==========================
Synopsis
--------
.. code-block:: c
mongoc_apm_callbacks_t *
mongoc_apm_callbacks_new (void);
Create a struct to hold event-notification callbacks.
Returns
-------
A new ``mongoc_apm_callbacks_t`` you must free with :symbol:`mongoc_apm_callbacks_destroy`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_callbacks_t.rst 0000664 0000000 0000000 00000001461 13226174053 0022360 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_callbacks_t
mongoc_apm_callbacks_t
======================
Notification callbacks
Synopsis
--------
Used to receive notification of events, such as when a MongoDB command begins, succeeds, or fails.
Create a ``mongoc_apm_callbacks_t`` with :symbol:`mongoc_apm_callbacks_new`, set callbacks on it, then pass it to :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_callbacks_destroy
mongoc_apm_callbacks_new
mongoc_apm_set_command_failed_cb
mongoc_apm_set_command_started_cb
mongoc_apm_set_command_succeeded_cb
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_command_name.rst 0000664 0000000 0000000 00000001326 13226174053 0026375 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_command_name
mongoc_apm_command_failed_get_command_name()
============================================
Synopsis
--------
.. code-block:: c
const char *
mongoc_apm_command_failed_get_command_name (
const mongoc_apm_command_failed_t *event);
Returns this event's command name. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
A string that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_context.rst 0000664 0000000 0000000 00000001164 13226174053 0025443 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_context
mongoc_apm_command_failed_get_context()
=======================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_command_failed_get_context (
const mongoc_apm_command_failed_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_duration.rst 0000664 0000000 0000000 00000001053 13226174053 0025601 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_duration
mongoc_apm_command_failed_get_duration()
========================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_failed_get_duration (
const mongoc_apm_command_failed_t *event);
Returns this event's duration in microseconds.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
The event's duration.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_error.rst 0000664 0000000 0000000 00000001151 13226174053 0025104 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_error
mongoc_apm_command_failed_get_error()
=====================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_command_failed_get_error (const mongoc_apm_command_failed_t *event,
bson_error_t *error);
Copies this event's error info.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
* ``error``: A :symbol:`bson:bson_error_t` to receive the event's error info.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_host.rst 0000664 0000000 0000000 00000001466 13226174053 0024741 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_host
mongoc_apm_command_failed_get_host()
====================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_command_failed_get_host (const mongoc_apm_command_failed_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_operation_id.rst 0000664 0000000 0000000 00000001302 13226174053 0026425 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_operation_id
mongoc_apm_command_failed_get_operation_id()
============================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_failed_get_operation_id (
const mongoc_apm_command_failed_t *event);
Returns this event's operation id. This number correlates all the commands in a bulk operation, or all the "find" and "getMore" commands required to stream a large query result.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
The event's operation id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_request_id.rst 0000664 0000000 0000000 00000001177 13226174053 0026127 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_request_id
mongoc_apm_command_failed_get_request_id()
==========================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_failed_get_request_id (
const mongoc_apm_command_failed_t *event);
Returns this event's wire-protocol request id. Use this number to correlate client-side events with server log messages.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
The event's request id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_get_server_id.rst 0000664 0000000 0000000 00000001042 13226174053 0025734 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_get_server_id
mongoc_apm_command_failed_get_server_id()
=========================================
Synopsis
--------
.. code-block:: c
uint32_t
mongoc_apm_command_failed_get_server_id (
const mongoc_apm_command_failed_t *event);
Returns this event's server id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_failed_t`.
Returns
-------
The event's server id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_failed_t.rst 0000664 0000000 0000000 00000001404 13226174053 0023360 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_failed_t
mongoc_apm_command_failed_t
===========================
Command-failed event
Synopsis
--------
An event notification sent when the driver fails to execute a MongoDB command.
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_command_failed_get_command_name
mongoc_apm_command_failed_get_context
mongoc_apm_command_failed_get_duration
mongoc_apm_command_failed_get_error
mongoc_apm_command_failed_get_host
mongoc_apm_command_failed_get_operation_id
mongoc_apm_command_failed_get_request_id
mongoc_apm_command_failed_get_server_id
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_command.rst 0000664 0000000 0000000 00000001324 13226174053 0025615 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_command
mongoc_apm_command_started_get_command()
========================================
Synopsis
--------
.. code-block:: c
const bson_t *
mongoc_apm_command_started_get_command (
const mongoc_apm_command_started_t *event);
Returns this event's command. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
A :symbol:`bson:bson_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_command_name.rst 0000664 0000000 0000000 00000001334 13226174053 0026616 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_command_name
mongoc_apm_command_started_get_command_name()
=============================================
Synopsis
--------
.. code-block:: c
const char *
mongoc_apm_command_started_get_command_name (
const mongoc_apm_command_started_t *event);
Returns this event's command name. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
A string that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_context.rst 0000664 0000000 0000000 00000001172 13226174053 0025664 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_context
mongoc_apm_command_started_get_context()
========================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_command_started_get_context (
const mongoc_apm_command_started_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_database_name.rst 0000664 0000000 0000000 00000001341 13226174053 0026742 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_database_name
mongoc_apm_command_started_get_database_name()
==============================================
Synopsis
--------
.. code-block:: c
const char *
mongoc_apm_command_started_get_database_name (
const mongoc_apm_command_started_t *event);
Returns this event's database name. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
A string that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_host.rst 0000664 0000000 0000000 00000001474 13226174053 0025162 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_host
mongoc_apm_command_started_get_host()
=====================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_command_started_get_host (const mongoc_apm_command_started_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_operation_id.rst 0000664 0000000 0000000 00000001310 13226174053 0026646 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_operation_id
mongoc_apm_command_started_get_operation_id()
=============================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_started_get_operation_id (
const mongoc_apm_command_started_t *event);
Returns this event's operation id. This number correlates all the commands in a bulk operation, or all the "find" and "getMore" commands required to stream a large query result.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
The event's operation id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_request_id.rst 0000664 0000000 0000000 00000001205 13226174053 0026341 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_request_id
mongoc_apm_command_started_get_request_id()
===========================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_started_get_request_id (
const mongoc_apm_command_started_t *event);
Returns this event's wire-protocol request id. Use this number to correlate client-side events with server log messages.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
The event's request id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_get_server_id.rst 0000664 0000000 0000000 00000001050 13226174053 0026155 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_get_server_id
mongoc_apm_command_started_get_server_id()
==========================================
Synopsis
--------
.. code-block:: c
uint32_t
mongoc_apm_command_started_get_server_id (
const mongoc_apm_command_started_t *event);
Returns this event's server id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_started_t`.
Returns
-------
The event's server id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_started_t.rst 0000664 0000000 0000000 00000001427 13226174053 0023607 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_started_t
mongoc_apm_command_started_t
============================
Command-started event
Synopsis
--------
An event notification sent when the driver begins executing a MongoDB command.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_command_started_get_command
mongoc_apm_command_started_get_command_name
mongoc_apm_command_started_get_context
mongoc_apm_command_started_get_database_name
mongoc_apm_command_started_get_host
mongoc_apm_command_started_get_operation_id
mongoc_apm_command_started_get_request_id
mongoc_apm_command_started_get_server_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_command_name.rst 0000664 0000000 0000000 00000001350 13226174053 0027072 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_command_name
mongoc_apm_command_succeeded_get_command_name()
===============================================
Synopsis
--------
.. code-block:: c
const char *
mongoc_apm_command_succeeded_get_command_name (
const mongoc_apm_command_succeeded_t *event);
Returns this event's command name. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
A string that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_context.rst 0000664 0000000 0000000 00000001206 13226174053 0026140 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_context
mongoc_apm_command_succeeded_get_context()
==========================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_command_succeeded_get_context (
const mongoc_apm_command_succeeded_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_duration.rst 0000664 0000000 0000000 00000001075 13226174053 0026305 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_duration
mongoc_apm_command_succeeded_get_duration()
===========================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_succeeded_get_duration (
const mongoc_apm_command_succeeded_t *event);
Returns this event's duration in microseconds.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
The event's duration.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_host.rst 0000664 0000000 0000000 00000001516 13226174053 0025435 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_host
mongoc_apm_command_succeeded_get_host()
=======================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_command_succeeded_get_host (
const mongoc_apm_command_succeeded_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_operation_id.rst 0000664 0000000 0000000 00000001324 13226174053 0027131 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_operation_id
mongoc_apm_command_succeeded_get_operation_id()
===============================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_succeeded_get_operation_id (
const mongoc_apm_command_succeeded_t *event);
Returns this event's operation id. This number correlates all the commands in a bulk operation, or all the "find" and "getMore" commands required to stream a large query result.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
The event's operation id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_reply.rst 0000664 0000000 0000000 00000001326 13226174053 0025612 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_reply
mongoc_apm_command_succeeded_get_reply()
========================================
Synopsis
--------
.. code-block:: c
const bson_t *
mongoc_apm_command_succeeded_get_reply (
const mongoc_apm_command_succeeded_t *event);
Returns this event's reply. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
A :symbol:`bson:bson_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_request_id.rst 0000664 0000000 0000000 00000001221 13226174053 0026615 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_request_id
mongoc_apm_command_succeeded_get_request_id()
=============================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_command_succeeded_get_request_id (
const mongoc_apm_command_succeeded_t *event);
Returns this event's wire-protocol request id. Use this number to correlate client-side events with server log messages.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
The event's request id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_get_server_id.rst 0000664 0000000 0000000 00000001064 13226174053 0026440 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_get_server_id
mongoc_apm_command_succeeded_get_server_id()
============================================
Synopsis
--------
.. code-block:: c
uint32_t
mongoc_apm_command_succeeded_get_server_id (
const mongoc_apm_command_succeeded_t *event);
Returns this event's server id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_command_succeeded_t`.
Returns
-------
The event's server id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_command_succeeded_t.rst 0000664 0000000 0000000 00000001455 13226174053 0024066 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_command_succeeded_t
mongoc_apm_command_succeeded_t
==============================
Command-succeeded event
Synopsis
--------
An event notification sent when the driver successfully executes a MongoDB command.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_command_succeeded_get_command_name
mongoc_apm_command_succeeded_get_context
mongoc_apm_command_succeeded_get_duration
mongoc_apm_command_succeeded_get_host
mongoc_apm_command_succeeded_get_operation_id
mongoc_apm_command_succeeded_get_reply
mongoc_apm_command_succeeded_get_request_id
mongoc_apm_command_succeeded_get_server_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_changed_get_context.rst 0000664 0000000 0000000 00000001164 13226174053 0025500 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_changed_get_context
mongoc_apm_server_changed_get_context()
=======================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_server_changed_get_context (
const mongoc_apm_server_changed_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_changed_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_changed_get_host.rst 0000664 0000000 0000000 00000001466 13226174053 0024776 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_changed_get_host
mongoc_apm_server_changed_get_host()
====================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_server_changed_get_host (const mongoc_apm_server_changed_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_changed_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_changed_get_new_description.rst 0000664 0000000 0000000 00000001433 13226174053 0027207 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_changed_get_new_description
mongoc_apm_server_changed_get_new_description()
===============================================
Synopsis
--------
.. code-block:: c
const mongoc_server_description_t *
mongoc_apm_server_changed_get_new_description (
const mongoc_apm_server_changed_t *event);
Returns this event's new description. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_changed_t`.
Returns
-------
A :symbol:`mongoc_server_description_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_changed_get_previous_description.rst 0000664 0000000 0000000 00000001464 13226174053 0030276 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_changed_get_previous_description
mongoc_apm_server_changed_get_previous_description()
====================================================
Synopsis
--------
.. code-block:: c
const mongoc_server_description_t *
mongoc_apm_server_changed_get_previous_description (
const mongoc_apm_server_changed_t *event);
Returns this event's previous description. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_changed_t`.
Returns
-------
A :symbol:`mongoc_server_description_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_changed_get_topology_id.rst 0000664 0000000 0000000 00000001226 13226174053 0026343 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_changed_get_topology_id
mongoc_apm_server_changed_get_topology_id()
===========================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_server_changed_get_topology_id (
const mongoc_apm_server_changed_t *event, bson_oid_t *topology_id);
Returns this event's topology id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_changed_t`.
* ``topology_id``: A :symbol:`bson:bson_oid_t` to receive the event's topology_id.
Returns
-------
The event's topology id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_changed_t.rst 0000664 0000000 0000000 00000001251 13226174053 0023415 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_changed_t
mongoc_apm_server_changed_t
===========================
Server-changed event
Synopsis
--------
An event notification sent when the driver observes a change in status of a server it is connected to.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_server_changed_get_context
mongoc_apm_server_changed_get_host
mongoc_apm_server_changed_get_new_description
mongoc_apm_server_changed_get_previous_description
mongoc_apm_server_changed_get_topology_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_closed_get_context.rst 0000664 0000000 0000000 00000001150 13226174053 0025353 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_closed_get_context
mongoc_apm_server_closed_get_context()
======================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_server_closed_get_context (const mongoc_apm_server_closed_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_closed_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_closed_get_host.rst 0000664 0000000 0000000 00000001460 13226174053 0024650 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_closed_get_host
mongoc_apm_server_closed_get_host()
===================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_server_closed_get_host (const mongoc_apm_server_closed_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_closed_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_closed_get_topology_id.rst 0000664 0000000 0000000 00000001220 13226174053 0026215 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_closed_get_topology_id
mongoc_apm_server_closed_get_topology_id()
==========================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_server_closed_get_topology_id (
const mongoc_apm_server_closed_t *event, bson_oid_t *topology_id);
Returns this event's topology id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_closed_t`.
* ``topology_id``: A :symbol:`bson:bson_oid_t` to receive the event's topology_id.
Returns
-------
The event's topology id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_closed_t.rst 0000664 0000000 0000000 00000001116 13226174053 0023275 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_closed_t
mongoc_apm_server_closed_t
==========================
Server-closed event
Synopsis
--------
An event notification sent when the driver stops monitoring a server and removes its :symbol:`mongoc_server_description_t`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_server_closed_get_context
mongoc_apm_server_closed_get_host
mongoc_apm_server_closed_get_topology_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_failed_get_context.rst 0000664 0000000 0000000 00000001252 13226174053 0027350 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_failed_get_context
mongoc_apm_server_heartbeat_failed_get_context()
================================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_server_heartbeat_failed_get_context (
const mongoc_apm_server_heartbeat_failed_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_failed_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_failed_get_duration.rst 0000664 0000000 0000000 00000001141 13226174053 0027506 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_failed_get_duration
mongoc_apm_server_heartbeat_failed_get_duration()
=================================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_server_heartbeat_failed_get_duration (
const mongoc_apm_server_heartbeat_failed_t *event);
Returns this event's duration in microseconds.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_failed_t`.
Returns
-------
The event's duration.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_failed_get_error.rst 0000664 0000000 0000000 00000001176 13226174053 0027022 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_failed_get_error
mongoc_apm_server_heartbeat_failed_get_error()
==============================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_server_heartbeat_failed_get_error (
const mongoc_apm_server_heartbeat_failed_t *event, bson_error_t *error);
Copies this event's error info.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_failed_t`.
* ``error``: A :symbol:`bson:bson_error_t` to receive the event's error info.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_failed_get_host.rst 0000664 0000000 0000000 00000001562 13226174053 0026645 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_failed_get_host
mongoc_apm_server_heartbeat_failed_get_host()
=============================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_server_heartbeat_failed_get_host (
const mongoc_apm_server_heartbeat_failed_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_failed_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_failed_t.rst 0000664 0000000 0000000 00000001260 13226174053 0025267 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_failed_t
mongoc_apm_server_heartbeat_failed_t
====================================
Heartbeat-failed event
Synopsis
--------
An event notification sent when the driver failed to send an "isMaster" command to check the status of a server.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_server_heartbeat_failed_get_context
mongoc_apm_server_heartbeat_failed_get_duration
mongoc_apm_server_heartbeat_failed_get_error
mongoc_apm_server_heartbeat_failed_get_host
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_started_get_context.rst 0000664 0000000 0000000 00000001260 13226174053 0027571 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_started_get_context
mongoc_apm_server_heartbeat_started_get_context()
=================================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_server_heartbeat_started_get_context (
const mongoc_apm_server_heartbeat_started_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_started_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_started_get_host.rst 0000664 0000000 0000000 00000001570 13226174053 0027066 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_started_get_host
mongoc_apm_server_heartbeat_started_get_host()
==============================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_server_heartbeat_started_get_host (
const mongoc_apm_server_heartbeat_started_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_started_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_started_t.rst 0000664 0000000 0000000 00000001123 13226174053 0025507 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_started_t
mongoc_apm_server_heartbeat_started_t
=====================================
Heartbeat-started event
Synopsis
--------
An event notification sent when the driver begins executing an "isMaster" command to check the status of a server.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_server_heartbeat_started_get_context
mongoc_apm_server_heartbeat_started_get_host
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_succeeded_get_context.rst 0000664 0000000 0000000 00000001274 13226174053 0030054 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_succeeded_get_context
mongoc_apm_server_heartbeat_succeeded_get_context()
===================================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_server_heartbeat_succeeded_get_context (
const mongoc_apm_server_heartbeat_succeeded_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_succeeded_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_succeeded_get_duration.rst 0000664 0000000 0000000 00000001163 13226174053 0030212 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_succeeded_get_duration
mongoc_apm_server_heartbeat_succeeded_get_duration()
====================================================
Synopsis
--------
.. code-block:: c
int64_t
mongoc_apm_server_heartbeat_succeeded_get_duration (
const mongoc_apm_server_heartbeat_succeeded_t *event);
Returns this event's duration in microseconds.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_succeeded_t`.
Returns
-------
The event's duration.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_succeeded_get_host.rst 0000664 0000000 0000000 00000001604 13226174053 0027342 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_succeeded_get_host
mongoc_apm_server_heartbeat_succeeded_get_host()
================================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_server_heartbeat_succeeded_get_host (
const mongoc_apm_server_heartbeat_succeeded_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_succeeded_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_succeeded_get_reply.rst 0000664 0000000 0000000 00000001414 13226174053 0027517 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_succeeded_get_reply
mongoc_apm_server_heartbeat_succeeded_get_reply()
=================================================
Synopsis
--------
.. code-block:: c
const bson_t *
mongoc_apm_server_heartbeat_succeeded_get_reply (
const mongoc_apm_server_heartbeat_succeeded_t *event);
Returns this event's reply. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_heartbeat_succeeded_t`.
Returns
-------
A :symbol:`bson:bson_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_heartbeat_succeeded_t.rst 0000664 0000000 0000000 00000001303 13226174053 0025765 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_heartbeat_succeeded_t
mongoc_apm_server_heartbeat_succeeded_t
=======================================
Heartbeat-succeeded event
Synopsis
--------
An event notification sent when the driver completes an "isMaster" command to check the status of a server.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_server_heartbeat_succeeded_get_context
mongoc_apm_server_heartbeat_succeeded_get_duration
mongoc_apm_server_heartbeat_succeeded_get_host
mongoc_apm_server_heartbeat_succeeded_get_reply
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_opening_get_context.rst 0000664 0000000 0000000 00000001164 13226174053 0025546 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_opening_get_context
mongoc_apm_server_opening_get_context()
=======================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_server_opening_get_context (
const mongoc_apm_server_opening_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_opening_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_opening_get_host.rst 0000664 0000000 0000000 00000001466 13226174053 0025044 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_opening_get_host
mongoc_apm_server_opening_get_host()
====================================
Synopsis
--------
.. code-block:: c
const mongoc_host_list_t *
mongoc_apm_server_opening_get_host (const mongoc_apm_server_opening_t *event);
Returns this event's host. This :symbol:`mongoc_host_list_t` is *not* part of a linked list, it is solely the server for this event. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_opening_t`.
Returns
-------
A :symbol:`mongoc_host_list_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_opening_get_topology_id.rst 0000664 0000000 0000000 00000001226 13226174053 0026411 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_opening_get_topology_id
mongoc_apm_server_opening_get_topology_id()
===========================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_server_opening_get_topology_id (
const mongoc_apm_server_opening_t *event, bson_oid_t *topology_id);
Returns this event's topology id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_server_opening_t`.
* ``topology_id``: A :symbol:`bson:bson_oid_t` to receive the event's topology_id.
Returns
-------
The event's topology id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_server_opening_t.rst 0000664 0000000 0000000 00000001140 13226174053 0023460 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_server_opening_t
mongoc_apm_server_opening_t
===========================
Server-opening event
Synopsis
--------
An event notification sent when the driver adds a :symbol:`mongoc_server_description_t` for a new server it was not monitoring before.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_server_opening_get_context
mongoc_apm_server_opening_get_host
mongoc_apm_server_opening_get_topology_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_set_command_failed_cb.rst 0000664 0000000 0000000 00000001434 13226174053 0024357 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_set_command_failed_cb
mongoc_apm_set_command_failed_cb()
==================================
Synopsis
--------
.. code-block:: c
typedef void (*mongoc_apm_command_failed_cb_t) (
const mongoc_apm_command_failed_t *event);
void
mongoc_apm_set_command_failed_cb (mongoc_apm_callbacks_t *callbacks,
mongoc_apm_command_failed_cb_t cb);
Receive an event notification whenever the driver fails to execute a MongoDB operation.
Parameters
----------
* ``callbacks``: A :symbol:`mongoc_apm_callbacks_t`.
* ``cb``: A function to call with a :symbol:`mongoc_apm_command_failed_t` whenever a MongoDB operation fails.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_set_command_started_cb.rst 0000664 0000000 0000000 00000001447 13226174053 0024605 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_set_command_started_cb
mongoc_apm_set_command_started_cb()
===================================
Synopsis
--------
.. code-block:: c
typedef void (*mongoc_apm_command_started_cb_t) (
const mongoc_apm_command_started_t *event);
void
mongoc_apm_set_command_started_cb (mongoc_apm_callbacks_t *callbacks,
mongoc_apm_command_started_cb_t cb);
Receive an event notification whenever the driver starts a MongoDB operation.
Parameters
----------
* ``callbacks``: A :symbol:`mongoc_apm_callbacks_t`.
* ``cb``: A function to call with a :symbol:`mongoc_apm_command_started_t` whenever the driver begins a MongoDB operation.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_set_command_succeeded_cb.rst 0000664 0000000 0000000 00000001477 13226174053 0025066 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_set_command_succeeded_cb
mongoc_apm_set_command_succeeded_cb()
=====================================
Synopsis
--------
.. code-block:: c
typedef void (*mongoc_apm_command_succeeded_cb_t) (
const mongoc_apm_command_succeeded_t *event);
void
mongoc_apm_set_command_succeeded_cb (mongoc_apm_callbacks_t *callbacks,
mongoc_apm_command_succeeded_cb_t cb);
Receive an event notification whenever the driver completes a MongoDB operation.
Parameters
----------
* ``callbacks``: A :symbol:`mongoc_apm_callbacks_t`.
* ``cb``: A function to call with a :symbol:`mongoc_apm_command_succeeded_t` whenever the driver completes a MongoDB operation.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_changed_get_context.rst 0000664 0000000 0000000 00000001200 13226174053 0026035 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_changed_get_context
mongoc_apm_topology_changed_get_context()
=========================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_topology_changed_get_context (
const mongoc_apm_topology_changed_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_changed_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_changed_get_new_description.rst 0000664 0000000 0000000 00000001453 13226174053 0027557 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_changed_get_new_description
mongoc_apm_topology_changed_get_new_description()
=================================================
Synopsis
--------
.. code-block:: c
const mongoc_topology_description_t *
mongoc_apm_topology_changed_get_new_description (
const mongoc_apm_topology_changed_t *event);
Returns this event's new description. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_changed_t`.
Returns
-------
A :symbol:`mongoc_topology_description_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_changed_get_previous_description.rst 0000664 0000000 0000000 00000001504 13226174053 0030637 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_changed_get_previous_description
mongoc_apm_topology_changed_get_previous_description()
======================================================
Synopsis
--------
.. code-block:: c
const mongoc_topology_description_t *
mongoc_apm_topology_changed_get_previous_description (
const mongoc_apm_topology_changed_t *event);
Returns this event's previous description. The data is only valid in the scope of the callback that receives this event; copy it if it will be accessed after the callback returns.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_changed_t`.
Returns
-------
A :symbol:`mongoc_topology_description_t` that should not be modified or freed.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_changed_get_topology_id.rst 0000664 0000000 0000000 00000001242 13226174053 0026707 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_changed_get_topology_id
mongoc_apm_topology_changed_get_topology_id()
=============================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_topology_changed_get_topology_id (
const mongoc_apm_topology_changed_t *event, bson_oid_t *topology_id);
Returns this event's topology id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_changed_t`.
* ``topology_id``: A :symbol:`bson:bson_oid_t` to receive the event's topology_id.
Returns
-------
The event's topology id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_changed_t.rst 0000664 0000000 0000000 00000001275 13226174053 0023771 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_changed_t
mongoc_apm_topology_changed_t
=============================
Topology-changed event
Synopsis
--------
An event notification sent when the driver observes a change in any of the servers it is connected to or a change in the overall server topology.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_topology_changed_get_context
mongoc_apm_topology_changed_get_new_description
mongoc_apm_topology_changed_get_previous_description
mongoc_apm_topology_changed_get_topology_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_closed_get_context.rst 0000664 0000000 0000000 00000001172 13226174053 0025725 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_closed_get_context
mongoc_apm_topology_closed_get_context()
========================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_topology_closed_get_context (
const mongoc_apm_topology_closed_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_closed_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_closed_get_topology_id.rst 0000664 0000000 0000000 00000001234 13226174053 0026570 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_closed_get_topology_id
mongoc_apm_topology_closed_get_topology_id()
============================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_topology_closed_get_topology_id (
const mongoc_apm_topology_closed_t *event, bson_oid_t *topology_id);
Returns this event's topology id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_closed_t`.
* ``topology_id``: A :symbol:`bson:bson_oid_t` to receive the event's topology_id.
Returns
-------
The event's topology id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_closed_t.rst 0000664 0000000 0000000 00000001100 13226174053 0023634 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_closed_t
mongoc_apm_topology_closed_t
============================
Topology-closed event
Synopsis
--------
An event notification sent when the driver stops monitoring a server topology and destroys its :symbol:`mongoc_topology_description_t`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_topology_closed_get_context
mongoc_apm_topology_closed_get_topology_id
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_opening_get_context.rst 0000664 0000000 0000000 00000001200 13226174053 0026103 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_opening_get_context
mongoc_apm_topology_opening_get_context()
=========================================
Synopsis
--------
.. code-block:: c
void *
mongoc_apm_topology_opening_get_context (
const mongoc_apm_topology_opening_t *event);
Returns this event's context.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_opening_t`.
Returns
-------
The pointer passed with :symbol:`mongoc_client_set_apm_callbacks` or :symbol:`mongoc_client_pool_set_apm_callbacks`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_opening_get_topology_id.rst 0000664 0000000 0000000 00000001242 13226174053 0026755 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_opening_get_topology_id
mongoc_apm_topology_opening_get_topology_id()
=============================================
Synopsis
--------
.. code-block:: c
void
mongoc_apm_topology_opening_get_topology_id (
const mongoc_apm_topology_opening_t *event, bson_oid_t *topology_id);
Returns this event's topology id.
Parameters
----------
* ``event``: A :symbol:`mongoc_apm_topology_opening_t`.
* ``topology_id``: A :symbol:`bson:bson_oid_t` to receive the event's topology_id.
Returns
-------
The event's topology id.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_apm_topology_opening_t.rst 0000664 0000000 0000000 00000001040 13226174053 0024025 0 ustar 00root root 0000000 0000000 :man_page: mongoc_apm_topology_opening_t
mongoc_apm_topology_opening_t
=============================
Topology-opening event
Synopsis
--------
An event notification sent when the driver initializes a :symbol:`mongoc_topology_description_t`.
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_apm_topology_opening_get_context
mongoc_apm_topology_opening_get_topology_id
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_delete.rst 0000664 0000000 0000000 00000001616 13226174053 0023622 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_delete
mongoc_bulk_operation_delete()
==============================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_delete (mongoc_bulk_operation_t *bulk,
const bson_t *selector);
Deletes documents as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
Deprecated
----------
.. warning::
This function is deprecated and should not be used in new code.
Please use :symbol:`mongoc_bulk_operation_remove()` instead.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t`.
See Also
--------
:symbol:`mongoc_bulk_operation_remove_many_with_opts()`
:symbol:`mongoc_bulk_operation_remove_one_with_opts()`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_delete_one.rst 0000664 0000000 0000000 00000001655 13226174053 0024466 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_delete_one
mongoc_bulk_operation_delete_one()
==================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_delete_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector);
Delete a single document as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
Deprecated
----------
.. warning::
This function is deprecated and should not be used in new code.
Please use :symbol:`mongoc_bulk_operation_remove_one()` instead.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t`.
See Also
--------
:symbol:`mongoc_bulk_operation_remove_one_with_opts()`
:symbol:`mongoc_bulk_operation_remove_many_with_opts()`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_destroy.rst 0000664 0000000 0000000 00000000552 13226174053 0024047 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_destroy
mongoc_bulk_operation_destroy()
===============================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_destroy (mongoc_bulk_operation_t *bulk);
Destroys a :symbol:`mongoc_bulk_operation_t` and frees the structure.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_execute.rst 0000664 0000000 0000000 00000003142 13226174053 0024016 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_execute
mongoc_bulk_operation_execute()
===============================
Synopsis
--------
.. code-block:: c
uint32_t
mongoc_bulk_operation_execute (mongoc_bulk_operation_t *bulk,
bson_t *reply,
bson_error_t *error);
This function executes all operations queued into the bulk operation. Unless ``ordered: false`` was specified in the ``opts`` passed to :symbol:`mongoc_collection_create_bulk_operation_with_opts()`, then forward progress will be stopped upon the first error.
It is only valid to call :symbol:`mongoc_bulk_operation_execute()` once. The ``mongoc_bulk_operation_t`` must be destroyed afterwards.
.. warning::
``reply`` is always initialized, even upon failure. Callers *must* call :symbol:`bson:bson_destroy()` to release this potential allocation.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``reply``: An uninitialized :symbol:`bson:bson_t`.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
See Also
--------
:symbol:`Bulk Write Operations `
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
On success, returns the server id used. On failure, returns 0 and sets ``error``.
A write concern timeout or write concern error is considered a failure.
The ``reply`` document counts operations and collects error information. See :doc:`Bulk Write Operations ` for examples.
See also :symbol:`mongoc_bulk_operation_get_hint`, which gets the id of the server used even if the operation failed.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_get_hint.rst 0000664 0000000 0000000 00000001544 13226174053 0024161 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_get_hint
mongoc_bulk_operation_get_hint()
================================
Synopsis
--------
.. code-block:: c
uint32_t
mongoc_bulk_operation_get_hint (const mongoc_bulk_operation_t *bulk);
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
Description
-----------
Retrieves the opaque id of the server used for the operation.
(The function name includes the old term "hint" for the sake of backward compatibility, but we now call this number a "server id".)
This number is zero until the driver actually uses a server in :symbol:`mongoc_bulk_operation_execute`. The server id is the same number as the return value of a successful :symbol:`mongoc_bulk_operation_execute`, so ``mongoc_bulk_operation_get_hint`` is useful mainly in case :symbol:`mongoc_bulk_operation_execute` fails and returns zero.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_get_write_concern.rst 0000664 0000000 0000000 00000001023 13226174053 0026050 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_get_write_concern
mongoc_bulk_operation_get_write_concern()
=========================================
Synopsis
--------
.. code-block:: c
const mongoc_write_concern_t *
mongoc_bulk_operation_get_write_concern (const mongoc_bulk_operation_t *bulk);
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
Description
-----------
Fetches the write concern to be used for ``bulk``.
Returns
-------
A :symbol:`mongoc_write_concern_t` that should not be modified or freed.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_insert.rst 0000664 0000000 0000000 00000001335 13226174053 0023662 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_insert
mongoc_bulk_operation_insert()
==============================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_insert (mongoc_bulk_operation_t *bulk,
const bson_t *document);
Queue an insert of a single document into a bulk operation. The insert is not performed until :symbol:`mongoc_bulk_operation_execute()` is called.
This function is superseded by :symbol:`mongoc_bulk_operation_insert_with_opts()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``document``: A :symbol:`bson:bson_t`.
See Also
--------
:doc:`bulk`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_insert_with_opts.rst 0000664 0000000 0000000 00000002252 13226174053 0025761 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_insert_with_opts
mongoc_bulk_operation_insert_with_opts()
========================================
Synopsis
--------
.. code-block:: c
bool
mongoc_bulk_operation_insert_with_opts (mongoc_bulk_operation_t *bulk,
const bson_t *document,
const bson_t *opts,
bson_error_t *error); /* OUT */
Queue an insert of a single document into a bulk operation. The insert is not performed until :symbol:`mongoc_bulk_operation_execute()` is called.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``document``: A :symbol:`bson:bson_t`.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
Currently the ``opts`` is unused.
Errors
------
Operation errors are propagated via :symbol:`mongoc_bulk_operation_execute()`, while argument validation errors are reported by the ``error`` argument.
Returns
-------
Returns true on success, and false if there is a server or network error or if passed invalid arguments.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_remove.rst 0000664 0000000 0000000 00000001651 13226174053 0023654 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_remove
mongoc_bulk_operation_remove()
==============================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_remove (mongoc_bulk_operation_t *bulk,
const bson_t *selector);
Remove documents as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
This function is superseded by :symbol:`mongoc_bulk_operation_remove_one_with_opts()` and :symbol:`mongoc_bulk_operation_remove_many_with_opts()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t`.
See Also
--------
:symbol:`mongoc_bulk_operation_remove_one()`
:symbol:`mongoc_bulk_operation_remove_one_with_opts()`
:symbol:`mongoc_bulk_operation_remove_many_with_opts()`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_remove_many_with_opts.rst 0000664 0000000 0000000 00000002500 13226174053 0026772 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_remove_many_with_opts
mongoc_bulk_operation_remove_many_with_opts()
=============================================
Synopsis
--------
.. code-block:: c
bool
mongoc_bulk_operation_remove_many_with_opts (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *opts,
bson_error_t *error); /* OUT */
Delete documents as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
See Also
--------
:symbol:`mongoc_bulk_operation_remove()`
:symbol:`mongoc_bulk_operation_remove_one_with_opts()`
Errors
------
Operation errors are propagated via :symbol:`mongoc_bulk_operation_execute()`, while argument validation errors are reported by the ``error`` argument.
Returns
-------
Returns true on success, and false if there is a server or network error or if passed invalid arguments.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_remove_one.rst 0000664 0000000 0000000 00000001601 13226174053 0024510 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_remove_one
mongoc_bulk_operation_remove_one()
==================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_remove_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector);
Remove a single document as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
This function is superseded by :symbol:`mongoc_bulk_operation_remove_one_with_opts()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
See Also
--------
:symbol:`mongoc_bulk_operation_remove_one_with_opts()`
:symbol:`mongoc_bulk_operation_remove_many_with_opts()`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_remove_one_with_opts.rst 0000664 0000000 0000000 00000002506 13226174053 0026615 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_remove_one_with_opts
mongoc_bulk_operation_remove_one_with_opts()
============================================
Synopsis
--------
.. code-block:: c
bool
mongoc_bulk_operation_remove_one_with_opts (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *opts,
bson_error_t *error); /* OUT */
Remove a single document as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
See Also
--------
:symbol:`mongoc_bulk_operation_remove_one()`
:symbol:`mongoc_bulk_operation_remove_many_with_opts()`
Errors
------
Operation errors are propagated via :symbol:`mongoc_bulk_operation_execute()`, while argument validation errors are reported by the ``error`` argument.
Returns
-------
Returns true on success, and false if there is a server or network error or if passed invalid arguments.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_replace_one.rst 0000664 0000000 0000000 00000002236 13226174053 0024633 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_replace_one
mongoc_bulk_operation_replace_one()
===================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_replace_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert);
Replace a single document as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
This function is superseded by :symbol:`mongoc_bulk_operation_replace_one_with_opts()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
* ``document``: A :symbol:`bson:bson_t` containing the replacement document.
* ``upsert``: ``true`` if this should be an ``upsert``.
.. warning::
``document`` may not contain fields with keys containing ``.`` or ``$``.
See Also
--------
:symbol:`mongoc_bulk_operation_replace_one_with_opts()`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_replace_one_with_opts.rst 0000664 0000000 0000000 00000003061 13226174053 0026730 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_replace_one_with_opts
mongoc_bulk_operation_replace_one_with_opts()
=============================================
Synopsis
--------
.. code-block:: c
bool
mongoc_bulk_operation_replace_one_with_opts (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
const bson_t *opts,
bson_error_t *error); /* OUT */
Replace a single document as part of a bulk operation. This only queues the operation. To execute it, call :symbol:`mongoc_bulk_operation_execute()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
* ``document``: A :symbol:`bson:bson_t` containing the replacement document.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: A :symbol:`bson:bson_error_t` any errors that may have occurred.
.. warning::
``document`` may not contain fields with keys containing ``.`` or ``$``.
See Also
--------
:symbol:`mongoc_bulk_operation_remove_many_with_opts()`
:symbol:`mongoc_bulk_operation_insert()`
Errors
------
Operation errors are propagated via :symbol:`mongoc_bulk_operation_execute()`, while argument validation errors are reported by the ``error`` argument.
Returns
-------
Returns true on success, and false if there is a server or network error or if passed invalid arguments.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_set_bypass_document_validation.rst 0000664 0000000 0000000 00000001163 13226174053 0030641 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_set_bypass_document_validation
mongoc_bulk_operation_set_bypass_document_validation()
======================================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_set_bypass_document_validation (
mongoc_bulk_operation_t *bulk, bool bypass);
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``bypass``: A boolean.
Description
-----------
Will bypass document validation for all operations part of this :doc:`bulk `.
See Also
--------
:ref:`bulk_operation_bypassing_document_validation`
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_set_client.rst 0000664 0000000 0000000 00000002221 13226174053 0024502 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_set_client
mongoc_bulk_operation_set_client()
==================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_set_client (mongoc_bulk_operation_t *bulk, void *client);
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``client``: A :symbol:`mongoc_client_t`.
Description
-----------
Specifies a client to use for the operation. This function has an effect only if called before :symbol:`mongoc_bulk_operation_execute`.
If a :symbol:`mongoc_client_session_t` has already been assigned with :symbol:`mongoc_bulk_operation_set_client_session`, the ``client`` parameter must be the same as the :symbol:`mongoc_client_t` associated with that :symbol:`mongoc_client_session_t`.
Use ``mongoc_bulk_operation_set_client`` only for building a language driver that wraps the C Driver. When writing applications in C, a client is implicitly set by :symbol:`mongoc_collection_create_bulk_operation_with_opts`.
The ``client`` parameter's type is a void pointer by mistake, but it must be preserved for ABI. You must only pass a :symbol:`mongoc_client_t` pointer for ``client``.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_set_client_session.rst 0000664 0000000 0000000 00000002037 13226174053 0026252 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_set_client_session
mongoc_bulk_operation_set_client_session()
==========================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_set_client_session (
mongoc_bulk_operation_t *bulk, mongoc_client_session_t *client_session);
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``client_session``: A :symbol:`mongoc_client_session_t`.
Description
-----------
Specifies a client session to use for the operation. This function has an effect only if called before :symbol:`mongoc_bulk_operation_execute`.
If a :symbol:`mongoc_client_t` has already been assigned with :symbol:`mongoc_bulk_operation_set_client`, the ``client_session`` parameter must be associated with the same :symbol:`mongoc_client_t`.
Use ``mongoc_bulk_operation_set_client_session`` only for building a language driver that wraps the C Driver. When writing applications in C, a client session should be specified via :symbol:`mongoc_collection_create_bulk_operation_with_opts`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_set_hint.rst 0000664 0000000 0000000 00000001663 13226174053 0024177 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_set_hint
mongoc_bulk_operation_set_hint()
================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_set_hint (const mongoc_bulk_operation_t *bulk,
uint32_t server_id);
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``server_id``: An opaque id identifying the server to use.
Description
-----------
Specifies which server to use for the operation. This function has an effect only if called before :symbol:`mongoc_bulk_operation_execute`.
(The function name includes the old term "hint" for the sake of backward compatibility, but we now call this number a "server id".)
Use ``mongoc_bulk_operation_set_hint`` only for building a language driver that wraps the C Driver. When writing applications in C, leave the server id unset and allow the driver to choose a suitable server for the bulk operation.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_t.rst 0000664 0000000 0000000 00000003220 13226174053 0022614 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_t
mongoc_bulk_operation_t
=======================
Bulk Write Operations
Synopsis
--------
.. code-block:: c
typedef struct _mongoc_bulk_operation_t mongoc_bulk_operation_t;
The opaque type ``mongoc_bulk_operation_t`` provides an abstraction for submitting multiple write operations as a single batch.
After adding all of the write operations to the ``mongoc_bulk_operation_t``, call :symbol:`mongoc_bulk_operation_execute()` to execute the operation.
.. warning::
It is only valid to call :symbol:`mongoc_bulk_operation_execute()` once. The ``mongoc_bulk_operation_t`` must be destroyed afterwards.
See Also
--------
:symbol:`Bulk Write Operations `
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_bulk_operation_delete
mongoc_bulk_operation_delete_one
mongoc_bulk_operation_destroy
mongoc_bulk_operation_execute
mongoc_bulk_operation_get_hint
mongoc_bulk_operation_get_write_concern
mongoc_bulk_operation_insert
mongoc_bulk_operation_insert_with_opts
mongoc_bulk_operation_remove
mongoc_bulk_operation_remove_many_with_opts
mongoc_bulk_operation_remove_one
mongoc_bulk_operation_remove_one_with_opts
mongoc_bulk_operation_replace_one
mongoc_bulk_operation_replace_one_with_opts
mongoc_bulk_operation_set_bypass_document_validation
mongoc_bulk_operation_set_client
mongoc_bulk_operation_set_client_session
mongoc_bulk_operation_set_hint
mongoc_bulk_operation_update
mongoc_bulk_operation_update_many_with_opts
mongoc_bulk_operation_update_one
mongoc_bulk_operation_update_one_with_opts
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_update.rst 0000664 0000000 0000000 00000002472 13226174053 0023643 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_update
mongoc_bulk_operation_update()
==============================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_update (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert);
This function queues an update as part of a bulk operation. This does not execute the operation. To execute the entirety of the bulk operation call :symbol:`mongoc_bulk_operation_execute()`.
``document`` MUST only contain fields whose key starts with ``$``. See the update document specification for more details.
This function is superseded by :symbol:`mongoc_bulk_operation_update_one_with_opts()` and :symbol:`mongoc_bulk_operation_update_many_with_opts()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which documents to remove.
* ``document``: A :symbol:`bson:bson_t` containing the update document.
* ``upsert``: ``true`` if an ``upsert`` should be performed.
See Also
--------
:symbol:`mongoc_bulk_operation_update_one_with_opts()`
:symbol:`mongoc_bulk_operation_update_many_with_opts()`
Errors
------
Errors are propagated via :symbol:`mongoc_bulk_operation_execute()`.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_update_many_with_opts.rst 0000664 0000000 0000000 00000003135 13226174053 0026764 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_update_many_with_opts
mongoc_bulk_operation_update_many_with_opts()
=============================================
Synopsis
--------
.. code-block:: c
bool
mongoc_bulk_operation_update_many_with_opts (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
const bson_t *opts,
bson_error_t *error); /* OUT */
This function queues an update as part of a bulk operation. This does not execute the operation. To execute the entirety of the bulk operation call :symbol:`mongoc_bulk_operation_execute()`.
.. warning::
``document`` MUST only contain fields whose key starts with ``$``. See the update document specification for more details.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which documents to remove.
* ``document``: A :symbol:`bson:bson_t` containing the update document.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: A :symbol:`bson:bson_error_t` any errors that may have occurred.
See Also
--------
:symbol:`mongoc_bulk_operation_update_one_with_opts()`
Errors
------
Operation errors are propagated via :symbol:`mongoc_bulk_operation_execute()`, while argument validation errors are reported by the ``error`` argument.
Returns
-------
Returns true on success, and false if there is a server or network error or if passed invalid arguments.
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_update_one.rst 0000664 0000000 0000000 00000002415 13226174053 0024501 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_update_one
mongoc_bulk_operation_update_one()
==================================
Synopsis
--------
.. code-block:: c
void
mongoc_bulk_operation_update_one (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
bool upsert);
This function queues an update as part of a bulk operation. It will only modify a single document on the MongoDB server. This function does not execute the operation. To execute the entirety of the bulk operation call :symbol:`mongoc_bulk_operation_execute()`.
This function is superseded by :symbol:`mongoc_bulk_operation_update_one_with_opts()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
* ``document``: A :symbol:`bson:bson_t` containing the update document.
* ``upsert``: ``true`` if an ``upsert`` should be performed.
.. warning::
``document`` *must only* contain fields whose key starts with ``$``. See the update document specification for more details.
See Also
--------
:symbol:`mongoc_bulk_operation_update()`
:symbol:`mongoc_bulk_operation_update_one_with_opts()`
libmongoc-1.9.2+dfsg/doc/mongoc_bulk_operation_update_one_with_opts.rst 0000664 0000000 0000000 00000003235 13226174053 0026602 0 ustar 00root root 0000000 0000000 :man_page: mongoc_bulk_operation_update_one_with_opts
mongoc_bulk_operation_update_one_with_opts()
============================================
Synopsis
--------
.. code-block:: c
bool
mongoc_bulk_operation_update_one_with_opts (mongoc_bulk_operation_t *bulk,
const bson_t *selector,
const bson_t *document,
const bson_t *opts,
bson_error_t *error); /* OUT */
This function queues an update as part of a bulk operation. It will only modify a single document on the MongoDB server. This function does not execute the operation. To execute the entirety of the bulk operation call :symbol:`mongoc_bulk_operation_execute()`.
Parameters
----------
* ``bulk``: A :symbol:`mongoc_bulk_operation_t`.
* ``selector``: A :symbol:`bson:bson_t` that selects which document to remove.
* ``document``: A :symbol:`bson:bson_t` containing the update document.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: A :symbol:`bson:bson_error_t` any errors that may have occurred.
.. warning::
``document`` *must only* contain fields whose key starts with ``$``. See the update document specification for more details.
See Also
--------
:symbol:`mongoc_bulk_operation_update_many_with_opts()`
Errors
------
Operation errors are propagated via :symbol:`mongoc_bulk_operation_execute()`, while argument validation errors are reported by the ``error`` argument.
Returns
-------
Returns true on success, and false if there is a server or network error or if passed invalid arguments.
libmongoc-1.9.2+dfsg/doc/mongoc_change_stream_destroy.rst 0000664 0000000 0000000 00000000531 13226174053 0023627 0 ustar 00root root 0000000 0000000 :man_page: mongoc_change_stream_destroy
mongoc_change_stream_destroy()
==============================
Synopsis
--------
.. code-block:: c
void
mongoc_change_stream_destroy (mongoc_change_stream_t *stream);
Destroys a change stream and associated data.
Parameters
----------
* ``stream``: An allocated :symbol:`mongoc_change_stream_t`. libmongoc-1.9.2+dfsg/doc/mongoc_change_stream_error_document.rst 0000664 0000000 0000000 00000001661 13226174053 0025172 0 ustar 00root root 0000000 0000000 :man_page: mongoc_change_stream_error_document
mongoc_change_stream_error_document()
=====================================
Synopsis
--------
.. code-block:: c
bool
mongoc_change_stream_error_document (mongoc_change_stream_t *stream,
bson_error_t *err,
const bson_t **reply);
Checks if an error has occurred when creating or iterating over a change stream.
Similar to :symbol:`mongoc_cursor_error_document` if the error has occurred
client-side then the ``reply`` will be set to an empty BSON document. If the
error occurred server-side, ``reply`` is set to the server's reply document.
Parameters
----------
* ``stream``: A :symbol:`mongoc_change_stream_t`.
* ``err``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
* ``reply``: A location for a :symbol:`bson:bson_t`.
Returns
-------
A boolean indicating if there was an error.
libmongoc-1.9.2+dfsg/doc/mongoc_change_stream_next.rst 0000664 0000000 0000000 00000002001 13226174053 0023106 0 ustar 00root root 0000000 0000000 :man_page: mongoc_change_stream_next
mongoc_change_stream_next()
===========================
Synopsis
--------
.. code-block:: c
bool
mongoc_change_stream_next (mongoc_change_stream_t *stream,
const bson_t **bson);
This function iterates the underlying cursor, setting ``bson`` to the next
document. This will block for a maximum of ``maxAwaitTimeMS`` milliseconds as
specified in the options when created, or the default timeout if omitted. Data
may be returned before the timeout. If no data is returned this function returns
``false``.
Parameters
----------
* ``stream``: A :symbol:`mongoc_change_stream_t` obtained from :symbol:`mongoc_collection_watch`.
* ``bson``: The location for the resulting document.
Returns
-------
A boolean indicating whether or not there was another document in the stream.
Similar to :symbol:`mongoc_cursor_next` the lifetime of ``bson`` is until the
next call to :symbol:`mongoc_change_stream_next`, so it needs to be copied to
extend the lifetime.
libmongoc-1.9.2+dfsg/doc/mongoc_change_stream_t.rst 0000664 0000000 0000000 00000001717 13226174053 0022410 0 ustar 00root root 0000000 0000000 :man_page: mongoc_change_stream_t
mongoc_change_stream_t
======================
Synopsis
--------
.. code-block:: c
#include
typedef struct _mongoc_change_stream_t mongoc_change_stream_t;
:symbol:`mongoc_change_stream_t` is a handle to a change stream. A collection
change stream can be obtained using :symbol:`mongoc_collection_watch`.
It is recommended to use a :symbol:`mongoc_change_stream_t` and its functions instead of a raw aggregation with a ``$changeStream`` stage. For more information see the `MongoDB Manual Entry on Change Streams `_.
Example
-------
.. literalinclude:: ../examples/example-collection-watch.c
:language: c
:caption: example-collection-watch.c
.. only:: html
Functions
---------
.. toctree::
:titlesonly:
:maxdepth: 1
mongoc_collection_watch
mongoc_change_stream_next
mongoc_change_stream_error_document
mongoc_change_stream_destroy
libmongoc-1.9.2+dfsg/doc/mongoc_check_version.rst 0000664 0000000 0000000 00000001051 13226174053 0022076 0 ustar 00root root 0000000 0000000 :man_page: mongoc_check_version
mongoc_check_version()
======================
Synopsis
--------
.. code-block:: c
bool
mongoc_check_version (int required_major,
int required_minor,
int required_micro);
Parameters
----------
* ``required_major``: The minimum major version required.
* ``required_minor``: The minimum minor version required.
* ``required_micro``: The minimum micro version required.
Returns
-------
True if libmongoc's version is greater than or equal to the required version.
libmongoc-1.9.2+dfsg/doc/mongoc_cleanup.rst 0000664 0000000 0000000 00000000305 13226174053 0020704 0 ustar 00root root 0000000 0000000 :man_page: mongoc_cleanup
mongoc_cleanup()
================
Synopsis
--------
.. code-block:: c
void
mongoc_cleanup (void);
Description
-----------
.. include:: includes/init_cleanup.txt
libmongoc-1.9.2+dfsg/doc/mongoc_client_command.rst 0000664 0000000 0000000 00000003530 13226174053 0022234 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_command
mongoc_client_command()
=======================
Synopsis
--------
.. code-block:: c
mongoc_cursor_t *
mongoc_client_command (mongoc_client_t *client,
const char *db_name,
mongoc_query_flags_t flags,
uint32_t skip,
uint32_t limit,
uint32_t batch_size,
const bson_t *query,
const bson_t *fields,
const mongoc_read_prefs_t *read_prefs);
This function is superseded by :symbol:`mongoc_client_command_with_opts()`, :symbol:`mongoc_client_read_command_with_opts()`, :symbol:`mongoc_client_write_command_with_opts()`, and :symbol:`mongoc_client_read_write_command_with_opts()`.
Description
-----------
This function creates a cursor which will execute the command when :symbol:`mongoc_cursor_next` is called on it. The client's read preference, read concern, and write concern are not applied to the command, and :symbol:`mongoc_cursor_next` will not check the server response for a write concern error or write concern timeout.
If :symbol:`mongoc_cursor_next()` returns ``false``, then retrieve error details with :symbol:`mongoc_cursor_error()` or :symbol:`mongoc_cursor_error_document()`.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``db_name``: The name of the database to run the command on.
* ``flags``: Unused.
* ``skip``: Unused.
* ``limit``: Unused.
* ``batch_size``: Unused.
* ``query``: A :symbol:`bson:bson_t` containing the command specification.
* ``fields``: Unused.
* ``read_prefs``: An optional :symbol:`mongoc_read_prefs_t`. Otherwise, the command uses mode ``MONGOC_READ_PRIMARY``.
Returns
-------
A :symbol:`mongoc_cursor_t`.
The cursor should be freed with :symbol:`mongoc_cursor_destroy()`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_command_simple.rst 0000664 0000000 0000000 00000003101 13226174053 0023577 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_command_simple
mongoc_client_command_simple()
==============================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_command_simple (mongoc_client_t *client,
const char *db_name,
const bson_t *command,
const mongoc_read_prefs_t *read_prefs,
bson_t *reply,
bson_error_t *error);
This is a simplified interface to :symbol:`mongoc_client_command()`. It returns the first document from the result cursor into ``reply``. The client's read preference, read concern, and write concern are not applied to the command.
.. warning::
``reply`` is always set, and should be released with :symbol:`bson:bson_destroy()`.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``db_name``: The name of the database to run the command on.
* ``command``: A :symbol:`bson:bson_t` containing the command specification.
* ``read_prefs``: An optional :symbol:`mongoc_read_prefs_t`. Otherwise, the command uses mode ``MONGOC_READ_PRIMARY``.
* ``reply``: A location for the resulting document.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
Returns ``true`` if successful. Returns ``false`` and sets ``error`` if there are invalid arguments or a server or network error.
This function does not check the server response for a write concern error or write concern timeout.
libmongoc-1.9.2+dfsg/doc/mongoc_client_command_simple_with_server_id.rst 0000664 0000000 0000000 00000002325 13226174053 0026703 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_command_simple_with_server_id
mongoc_client_command_simple_with_server_id()
=============================================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_command_simple_with_server_id (
mongoc_client_t *client,
const char *db_name,
const bson_t *command,
const mongoc_read_prefs_t *read_prefs,
uint32_t server_id bson_t *reply,
bson_error_t *error);
This function executes a command on a specific server, using the database and command specification provided.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``db_name``: The name of the database to run the command on.
* ``read_prefs``: An optional :symbol:`mongoc_read_prefs_t`.
* ``server_id``: An opaque id specifying which server to use.
* ``reply``: An optional location for a :symbol:`bson:bson_t` which will store the server's reply.
* ``error``: An optional location for a :symbol:`bson_error_t ` or a ``NULL``.
Returns
-------
Returns ``true`` if successful. Returns ``false`` and sets ``error`` if there are invalid arguments or a server or network error.
This function does not check the server response for a write concern error or write concern timeout.
libmongoc-1.9.2+dfsg/doc/mongoc_client_command_with_opts.rst 0000664 0000000 0000000 00000003537 13226174053 0024343 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_command_with_opts
mongoc_client_command_with_opts()
=================================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_command_with_opts (
mongoc_client_t *client,
const char *db_name,
const bson_t *command,
const mongoc_read_prefs_t *read_prefs,
const bson_t *opts,
bson_t *reply,
bson_error_t *error);
Execute a command on the server, interpreting ``opts`` according to the MongoDB server version. To send a raw command to the server without any of this logic, use :symbol:`mongoc_client_command_simple`.
Read preferences are applied from ``read_prefs`` or else from ``client``. Collation, read concern, and write concern are applied from ``opts`` (:ref:`see example for the "distinct" command with opts `). The write concern is ignored for MongoDB before 3.4.
``reply`` is always initialized, and must be freed with :symbol:`bson:bson_destroy()`.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``db_name``: The name of the database to run the command on.
* ``command``: A :symbol:`bson:bson_t` containing the command specification.
* ``read_prefs``: An optional :symbol:`mongoc_read_prefs_t`.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``reply``: A location for the resulting document.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
.. include:: includes/read-write-opts.txt
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
Returns ``true`` if successful. Returns ``false`` and sets ``error`` if there are invalid arguments or a server or network error.
The reply is not parsed for a write concern timeout or write concern error.
Example
-------
See the example code for :symbol:`mongoc_client_read_command_with_opts`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_destroy.rst 0000664 0000000 0000000 00000000501 13226174053 0022302 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_destroy
mongoc_client_destroy()
=======================
Synopsis
--------
.. code-block:: c
void
mongoc_client_destroy (mongoc_client_t *client);
Release all resources associated with ``client`` and free the structure.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_find_databases_with_opts.rst 0000664 0000000 0000000 00000001356 13226174053 0025651 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_find_databases_with_opts
mongoc_client_find_databases_with_opts()
========================================
Synopsis
--------
.. code-block:: c
mongoc_cursor_t *
mongoc_client_find_databases_with_opts (mongoc_client_t *client,
const bson_t *opts);
Fetches a cursor containing documents, each corresponding to a database on this MongoDB server.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
Errors
------
Use :symbol:`mongoc_cursor_error` on the returned cursor to check for errors.
Returns
-------
A cursor where each result corresponds to the server's representation of a database.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_collection.rst 0000664 0000000 0000000 00000001655 13226174053 0023616 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_collection
mongoc_client_get_collection()
==============================
Synopsis
--------
.. code-block:: c
mongoc_collection_t *
mongoc_client_get_collection (mongoc_client_t *client,
const char *db,
const char *collection);
Get a newly allocated :symbol:`mongoc_collection_t` for the collection named ``collection`` in the database named ``db``.
.. tip::
Collections are automatically created on the MongoDB server upon insertion of the first document. There is no need to create a collection manually.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``db``: The name of the database containing the collection.
* ``collection``: The name of the collection.
Returns
-------
A newly allocated :symbol:`mongoc_collection_t` that should be freed with :symbol:`mongoc_collection_destroy()` when no longer in use.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_database.rst 0000664 0000000 0000000 00000001374 13226174053 0023225 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_database
mongoc_client_get_database()
============================
Synopsis
--------
.. code-block:: c
mongoc_database_t *
mongoc_client_get_database (mongoc_client_t *client, const char *name);
Get a newly allocated :symbol:`mongoc_database_t` for the database named ``name``.
.. tip::
Databases are automatically created on the MongoDB server upon insertion of the first document into a collection. There is no need to create a database manually.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``name``: The name of the database.
Returns
-------
A newly allocated :symbol:`mongoc_database_t ` that should be freed with :symbol:`mongoc_database_destroy()` when no longer in use.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_database_names.rst 0000664 0000000 0000000 00000001645 13226174053 0024411 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_database_names
mongoc_client_get_database_names()
==================================
Synopsis
--------
.. code-block:: c
char **
mongoc_client_get_database_names (mongoc_client_t *client, bson_error_t *error);
Deprecated
----------
This function is deprecated and should not be used in new code.
Please use :symbol:`mongoc_client_get_database_names_with_opts()` instead.
Description
-----------
This function queries the MongoDB server for a list of known databases.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
A ``NULL`` terminated vector of ``NULL-byte`` terminated strings. The result should be freed with :symbol:`bson:bson_strfreev()`.
``NULL`` is returned upon failure and ``error`` is set.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_database_names_with_opts.rst 0000664 0000000 0000000 00000002502 13226174053 0026502 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_database_names_with_opts
mongoc_client_get_database_names_with_opts()
============================================
Synopsis
--------
.. code-block:: c
char **
mongoc_client_get_database_names_with_opts (mongoc_client_t *client,
const bson_t *opts,
bson_error_t *error);
This function queries the MongoDB server for a list of known databases.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``opts``: A :symbol:`bson:bson_t` containing additional options.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
A ``NULL`` terminated vector of ``NULL-byte`` terminated strings. The result should be freed with :symbol:`bson:bson_strfreev()`.
``NULL`` is returned upon failure and ``error`` is set.
Examples
--------
.. code-block:: c
{
bson_error_t error;
char **strv;
unsigned i;
if ((strv = mongoc_client_get_database_names_with_opts (client, NULL, &error))) {
for (i = 0; strv[i]; i++)
printf ("%s\n", strv[i]);
bson_strfreev (strv);
} else {
fprintf (stderr, "Command failed: %s\n", error.message);
}
}
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_default_database.rst 0000664 0000000 0000000 00000002311 13226174053 0024721 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_default_database
mongoc_client_get_default_database()
====================================
Synopsis
--------
.. code-block:: c
mongoc_database_t *
mongoc_client_get_default_database (mongoc_client_t *client);
Get the database named in the MongoDB connection URI, or ``NULL`` if the URI specifies none.
Useful when you want to choose which database to use based only on the URI in a configuration file.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
A newly allocated :symbol:`mongoc_database_t ` that should be freed with :symbol:`mongoc_database_destroy()`.
Example
-------
.. code-block:: c
:caption: Default Database Example
/* default database is "db_name" */
mongoc_client_t *client = mongoc_client_new ("mongodb://host/db_name");
mongoc_database_t *db = mongoc_client_get_default_database (client);
assert (!strcmp ("db_name", mongoc_database_get_name (db)));
mongoc_database_destroy (db);
mongoc_client_destroy (client);
/* no default database */
client = mongoc_client_new ("mongodb://host/");
db = mongoc_client_get_default_database (client);
assert (!db);
mongoc_client_destroy (client);
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_gridfs.rst 0000664 0000000 0000000 00000002242 13226174053 0022732 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_gridfs
mongoc_client_get_gridfs()
==========================
Synopsis
--------
.. code-block:: c
mongoc_gridfs_t *
mongoc_client_get_gridfs (mongoc_client_t *client,
const char *db,
const char *prefix,
bson_error_t *error);
The ``mongoc_client_get_gridfs()`` function shall create a new :symbol:`mongoc_gridfs_t`. The ``db`` parameter is the name of the database which the gridfs instance should exist in. The ``prefix`` parameter corresponds to the gridfs collection namespacing; its default is "fs", thus the default GridFS collection names are "fs.files" and "fs.chunks".
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``db``: The database name.
* ``prefix``: Optional prefix for gridfs collection names or ``NULL``.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
On success, returns a :symbol:`mongoc_gridfs_t` you must free with :symbol:`mongoc_gridfs_destroy()`. Returns ``NULL`` upon failure and sets ``error``.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_max_bson_size.rst 0000664 0000000 0000000 00000001242 13226174053 0024313 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_max_bson_size
mongoc_client_get_max_bson_size()
=================================
Synopsis
--------
.. code-block:: c
int32_t
mongoc_client_get_max_bson_size (mongoc_client_t *client);
The :symbol:`mongoc_client_get_max_bson_size()` returns the maximum bson document size allowed by the cluster. Until a connection has been made, this will be the default of 16Mb.
Deprecated
----------
.. warning::
This function is deprecated and should not be used in new code.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
The server provided max bson size, or 16Mb if no connection has been established.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_max_message_size.rst 0000664 0000000 0000000 00000001256 13226174053 0025003 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_max_message_size
mongoc_client_get_max_message_size()
====================================
Synopsis
--------
.. code-block:: c
int32_t
mongoc_client_get_max_message_size (mongoc_client_t *client);
The :symbol:`mongoc_client_get_max_message_size()` returns the maximum message size allowed by the cluster. Until a connection has been made, this will be the default of 40Mb.
Deprecated
----------
.. warning::
This function is deprecated and should not be used in new code.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
The server provided max message size, or 40Mb if no connection has been established.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_read_concern.rst 0000664 0000000 0000000 00000000742 13226174053 0024101 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_read_concern
mongoc_client_get_read_concern()
================================
Synopsis
--------
.. code-block:: c
const mongoc_read_concern_t *
mongoc_client_get_read_concern (const mongoc_client_t *client);
Retrieve the default read concern configured for the client instance. The result should not be modified or freed.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
A :symbol:`mongoc_read_concern_t`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_read_prefs.rst 0000664 0000000 0000000 00000000733 13226174053 0023571 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_read_prefs
mongoc_client_get_read_prefs()
==============================
Synopsis
--------
.. code-block:: c
const mongoc_read_prefs_t *
mongoc_client_get_read_prefs (const mongoc_client_t *client);
Retrieves the default read preferences configured for the client instance. The result should not be modified or freed.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
A :symbol:`mongoc_read_prefs_t`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_server_description.rst 0000664 0000000 0000000 00000001264 13226174053 0025370 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_server_description
mongoc_client_get_server_description()
======================================
Synopsis
--------
.. code-block:: c
mongoc_server_description_t *
mongoc_client_get_server_description (mongoc_client_t *client,
uint32_t server_id);
Get information about the server specified by ``server_id``.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``server_id``: An opaque id specifying the server.
Returns
-------
A :symbol:`mongoc_server_description_t` that must be freed with :symbol:`mongoc_server_description_destroy`. If the server is no longer in the topology, returns NULL.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_server_descriptions.rst 0000664 0000000 0000000 00000003171 13226174053 0025552 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_server_descriptions
mongoc_client_get_server_descriptions()
=======================================
Synopsis
--------
.. code-block:: c
mongoc_server_description_t **
mongoc_client_get_server_descriptions (const mongoc_client_t *client,
size_t *n);
Fetches an array of :symbol:`mongoc_server_description_t` structs for all known servers in the topology. Returns no servers until the client connects. Returns a single server if the client is directly connected, or all members of a replica set if the client's MongoDB URI includes a "replicaSet" option, or all known mongos servers if the MongoDB URI includes a list of them.
.. code-block:: c
void
show_servers (const mongoc_client_t *client)
{
bson_t *b = BCON_NEW ("ping", BCON_INT32 (1));
bson_error_t error;
bool r;
mongoc_server_description_t **sds;
size_t i, n;
/* ensure client has connected */
r = mongoc_client_command_simple (client, "db", b, NULL, NULL, &error);
if (!r) {
MONGOC_ERROR ("could not connect: %s\n", error.message);
return;
}
sds = mongoc_client_get_server_descriptions (client, &n);
for (i = 0; i < n; ++i) {
printf ("%s\n", mongoc_server_description_host (sds[i])->host_and_port);
}
mongoc_server_descriptions_destroy_all (sds, n);
bson_destroy (&b);
}
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``n``: Receives the length of the descriptions array.
Returns
-------
A newly allocated array that must be freed with :symbol:`mongoc_server_descriptions_destroy_all`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_server_status.rst 0000664 0000000 0000000 00000002110 13226174053 0024357 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_server_status
mongoc_client_get_server_status()
=================================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_get_server_status (mongoc_client_t *client,
mongoc_read_prefs_t *read_prefs,
bson_t *reply,
bson_error_t *error);
Queries the server for the current server status. The result is stored in ``reply``.
.. warning::
``reply`` is always initialized, even in the case of failure. Always call :symbol:`bson:bson_destroy()` to release it.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
* ``read_prefs``: A :symbol:`mongoc_read_prefs_t`.
* ``reply``: A location for the result :symbol:`bson:bson_t`.
* ``error``: An optional location for a :symbol:`bson_error_t ` or ``NULL``.
Errors
------
Errors are propagated via the ``error`` parameter.
Returns
-------
Returns ``true`` if successful. Returns ``false`` and sets ``error`` if there are invalid arguments or a server or network error.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_uri.rst 0000664 0000000 0000000 00000000635 13226174053 0022257 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_uri
mongoc_client_get_uri()
=======================
Synopsis
--------
.. code-block:: c
const mongoc_uri_t *
mongoc_client_get_uri (const mongoc_client_t *client);
Fetches the :symbol:`mongoc_uri_t` used to create the client.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
A :symbol:`mongoc_uri_t` that should not be modified or freed.
libmongoc-1.9.2+dfsg/doc/mongoc_client_get_write_concern.rst 0000664 0000000 0000000 00000000751 13226174053 0024320 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_get_write_concern
mongoc_client_get_write_concern()
=================================
Synopsis
--------
.. code-block:: c
const mongoc_write_concern_t *
mongoc_client_get_write_concern (const mongoc_client_t *client);
Retrieve the default write concern configured for the client instance. The result should not be modified or freed.
Parameters
----------
* ``client``: A :symbol:`mongoc_client_t`.
Returns
-------
A :symbol:`mongoc_write_concern_t`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_new.rst 0000664 0000000 0000000 00000000777 13226174053 0021421 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_new
mongoc_client_new()
===================
Synopsis
--------
.. code-block:: c
mongoc_client_t *
mongoc_client_new (const char *uri_string);
Creates a new :symbol:`mongoc_client_t` using the URI string provided.
Parameters
----------
* ``uri_string``: A string containing the MongoDB connection URI.
Returns
-------
A newly allocated :symbol:`mongoc_client_t` if the URI parsed successfully, otherwise ``NULL``.
See Also
--------
:symbol:`mongoc_client_new_from_uri()`
libmongoc-1.9.2+dfsg/doc/mongoc_client_new_from_uri.rst 0000664 0000000 0000000 00000000767 13226174053 0023322 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_new_from_uri
mongoc_client_new_from_uri()
============================
Synopsis
--------
.. code-block:: c
mongoc_client_t *
mongoc_client_new_from_uri (const mongoc_uri_t *uri);
Creates a new :symbol:`mongoc_client_t` using the :symbol:`mongoc_uri_t` provided.
Parameters
----------
* ``uri``: A :symbol:`mongoc_uri_t`.
Returns
-------
A newly allocated :symbol:`mongoc_client_t` that should be freed with :symbol:`mongoc_client_destroy()` when no longer in use.
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_destroy.rst 0000664 0000000 0000000 00000000543 13226174053 0023341 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_destroy
mongoc_client_pool_destroy()
============================
Synopsis
--------
.. code-block:: c
void
mongoc_client_pool_destroy (mongoc_client_pool_t *pool);
Release all resources associated with ``pool``, including freeing the structure.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_max_size.rst 0000664 0000000 0000000 00000001122 13226174053 0023461 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_max_size
mongoc_client_pool_max_size()
=============================
Synopsis
--------
.. code-block:: c
void
mongoc_client_pool_min_size (mongoc_client_pool_t *pool,
uint32_t max_pool_size);
This function sets the maximum number of pooled connections available from a :symbol:`mongoc_client_pool_t`.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
* ``max_pool_size``: The maximum number of connections which shall be available from the pool.
.. include:: includes/mongoc_client_pool_thread_safe.txt
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_min_size.rst 0000664 0000000 0000000 00000002151 13226174053 0023462 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_min_size
mongoc_client_pool_min_size()
=============================
Synopsis
--------
.. code-block:: c
void
mongoc_client_pool_min_size (mongoc_client_pool_t *pool,
uint32_t min_pool_size)
BSON_GNUC_DEPRECATED;
This function sets the *maximum* number of idle clients to be kept in the pool. Any idle clients in excess of the maximum are destroyed. This function is deprecated because its behavior does not match what developers expect from a "minimum pool size", and its actual behavior is likely to hurt performance.
Applications should not call this function, they should instead accept the default behavior, which is to keep all idle clients that are pushed into the pool.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
* ``min_pool_size``: The number of idle clients to keep in the pool.
.. include:: includes/mongoc_client_pool_thread_safe.txt
Subsequent calls to :symbol:`mongoc_client_pool_push` respect the new minimum size, and close the least recently used :symbol:`mongoc_client_t` if the minimum size is exceeded.
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_new.rst 0000664 0000000 0000000 00000001011 13226174053 0022430 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_new
mongoc_client_pool_new()
========================
Synopsis
--------
.. code-block:: c
mongoc_client_pool_t *
mongoc_client_pool_new (const mongoc_uri_t *uri);
This function creates a new :symbol:`mongoc_client_pool_t` using the :symbol:`mongoc_uri_t` provided.
Parameters
----------
* ``uri``: A :symbol:`mongoc_uri_t`.
Returns
-------
A newly allocated :symbol:`mongoc_client_pool_t` that should be freed with :symbol:`mongoc_client_pool_destroy()` when no longer in use.
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_pop.rst 0000664 0000000 0000000 00000000734 13226174053 0022450 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_pop
mongoc_client_pool_pop()
========================
Synopsis
--------
.. code-block:: c
mongoc_client_t *
mongoc_client_pool_pop (mongoc_client_pool_t *pool);
Retrieve a :symbol:`mongoc_client_t` from the client pool, possibly blocking until one is available.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
Returns
-------
A :symbol:`mongoc_client_t`.
.. include:: includes/mongoc_client_pool_thread_safe.txt
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_push.rst 0000664 0000000 0000000 00000000716 13226174053 0022631 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_push
mongoc_client_pool_push()
=========================
Synopsis
--------
.. code-block:: c
void
mongoc_client_pool_push (mongoc_client_pool_t *pool, mongoc_client_t *client);
This function returns a :symbol:`mongoc_client_t` back to the client pool.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
* ``client``: A :symbol:`mongoc_client_t`.
.. include:: includes/mongoc_client_pool_thread_safe.txt
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_set_apm_callbacks.rst 0000664 0000000 0000000 00000001641 13226174053 0025277 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_set_apm_callbacks
mongoc_client_pool_set_apm_callbacks()
======================================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_pool_set_apm_callbacks (mongoc_client_pool_t *pool,
mongoc_apm_callbacks_t *callbacks,
void *context);
Register a set of callbacks to receive Application Performance Monitoring events.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
* ``callbacks``: A :symbol:`mongoc_apm_callbacks_t`.
* ``context``: Optional pointer to include with each event notification.
Returns
-------
Returns true on success. If any arguments are invalid, returns false and logs an error.
.. include:: includes/mongoc_client_pool_call_once.txt
See Also
--------
:doc:`Introduction to Application Performance Monitoring `
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_set_appname.rst 0000664 0000000 0000000 00000001400 13226174053 0024135 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_set_appname
mongoc_client_pool_set_appname()
================================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_pool_set_appname (mongoc_client_pool_t *pool, const char *appname)
This function is identical to :symbol:`mongoc_client_set_appname()` except for client pools.
Also note that :symbol:`mongoc_client_set_appname()` cannot be called on a client retrieved from a client pool.
Parameters
----------
* ``pool``: A :symbol:`mongoc_client_pool_t`.
* ``appname``: The application name, of length at most ``MONGOC_HANDSHAKE_APPNAME_MAX``.
Returns
-------
Returns true if appname was set. If appname is too long, returns false and logs an error.
.. include:: includes/mongoc_client_pool_call_once.txt
libmongoc-1.9.2+dfsg/doc/mongoc_client_pool_set_error_api.rst 0000664 0000000 0000000 00000001412 13226174053 0024501 0 ustar 00root root 0000000 0000000 :man_page: mongoc_client_pool_set_error_api
mongoc_client_pool_set_error_api()
==================================
Synopsis
--------
.. code-block:: c
bool
mongoc_client_pool_set_error_api (mongoc_client_pool_t *client,
int32_t version);
Configure how the C Driver reports errors. See :ref:`Setting the Error API Version