--- /dev/null
+cmake_minimum_required(VERSION 2.8.11)
+
+project(Ceph)
+set(VERSION "0.88")
+
+# Tweak policies (this one disables "missing" dependency warning)
+cmake_policy(SET CMP0046 OLD)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
+
+include_directories(
+ ${PROJECT_BINARY_DIR}/src/include
+ ${OFED_PREFIX}/include
+ ${LEVELDB_PREFIX}/include
+)
+
+link_directories(
+ ${OFED_PREFIX}/lib
+ ${LEVELDB_PREFIX}/lib
+)
+
+#Check Includes
+include(CheckIncludeFiles)
+include(CheckIncludeFileCXX)
+include(CheckFunctionExists)
+
+CHECK_FUNCTION_EXISTS(fallocate CEPH_HAVE_FALLOCATE)
+CHECK_FUNCTION_EXISTS(posix_fadvise HAVE_POSIX_FADVISE)
+CHECK_FUNCTION_EXISTS(posix_fallocate HAVE_POSIX_FALLOCATE)
+CHECK_FUNCTION_EXISTS(syncfs HAVE_SYS_SYNCFS)
+CHECK_FUNCTION_EXISTS(sync_file_range HAVE_SYNC_FILE_RANGE)
+CHECK_INCLUDE_FILES("arpa/inet.h" HAVE_ARPA_INET_H)
+CHECK_INCLUDE_FILES("boost/random/discrete_distribution.hpp" HAVE_BOOST_RANDOM_DISCRETE_DISTRIBUTION)
+CHECK_INCLUDE_FILES("dirent.h" HAVE_DIRENT_H)
+CHECK_INCLUDE_FILES("dlfcn.h" HAVE_DLFCN_H)
+CHECK_INCLUDE_FILES("inttypes.h" HAVE_INTTYPES_H)
+CHECK_INCLUDE_FILES("linux/types.h" HAVE_LINUX_TYPES_H)
+CHECK_INCLUDE_FILES("leveldb/filter_policy.h" HAVE_LEVELDB_FILTER_POLICY)
+CHECK_INCLUDE_FILES("memory.h" HAVE_MEMORY_H)
+CHECK_INCLUDE_FILES("ndir.h" HAVE_NDIR_H)
+CHECK_INCLUDE_FILES("netdb.h" HAVE_NETDB_H)
+CHECK_INCLUDE_FILES("netinet/in.h" HAVE_NETINET_IN_H)
+CHECK_INCLUDE_FILES("stdint.h" HAVE_STDINT_H)
+CHECK_INCLUDE_FILES("stdlib.h" HAVE_STDLIB_H)
+CHECK_INCLUDE_FILES("arpa/inet.h" HAVE_ARPA_INET_H)
+CHECK_INCLUDE_FILES("strings.h" HAVE_STRINGS_H)
+CHECK_INCLUDE_FILES("string.h" HAVE_STRING_H)
+CHECK_INCLUDE_FILES("syslog.h" HAVE_SYSLOG_H)
+CHECK_INCLUDE_FILES("sys/dir.h" HAVE_SYS_DIR_H)
+CHECK_INCLUDE_FILES("sys/file.h" HAVE_SYS_FILE_H)
+CHECK_INCLUDE_FILES("sys/ioctl.h" HAVE_SYS_IOCTL_H)
+CHECK_INCLUDE_FILES("sys/mount.h" HAVE_SYS_MOUNT_H)
+CHECK_INCLUDE_FILES("sys/ndir.h" HAVE_SYS_NDIR_H)
+CHECK_INCLUDE_FILES("sys/param.h" HAVE_SYS_PARAM_H)
+CHECK_INCLUDE_FILES("sys/socket.h" HAVE_SYS_SOCKET_H)
+CHECK_INCLUDE_FILES("sys/statvfs.h" HAVE_SYS_STATVFS_H)
+CHECK_INCLUDE_FILES("sys/stat.h" HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILES("sys/time.h" HAVE_SYS_TIME_H)
+CHECK_INCLUDE_FILES("sys/types.h" HAVE_SYS_TYPES_H)
+CHECK_INCLUDE_FILES("sys/vfs.h" HAVE_SYS_VFS_H)
+CHECK_INCLUDE_FILES("sys/wait.h" HAVE_SYS_WAIT_H)
+CHECK_INCLUDE_FILES("sys/xattr.h" HAVE_SYS_XATTR_H)
+CHECK_INCLUDE_FILES("unistd.h" HAVE_UNISTD_H)
+CHECK_INCLUDE_FILES("utime.h" HAVE_UTIME_H)
+CHECK_INCLUDE_FILES("${CMAKE_SOURCE_DIR}/src/include/fiemap.h" HAVE_FIEMAP_H)
+CHECK_INCLUDE_FILES("expat.h" HAVE_EXPAT_H)
+CHECK_INCLUDE_FILES("fuse/fuse_lowlevel.h" HAVE_FUSE_LOWLEVEL_H)
+CHECK_INCLUDE_FILES("curl/curl.h" HAVE_FUSE_LOWLEVEL_H)
+CHECK_INCLUDE_FILES("fuse/fuse.h" HAVE_FUSE_H)
+CHECK_INCLUDE_FILES("google/profiler.h" HAVE_PROFILER_H)
+CHECK_INCLUDE_FILES("libedit/vis.h" HAVE_LIBEDIT_VIS_H)
+CHECK_INCLUDE_FILES("fcgi_config.h" HAVE_FASTCGI_CONFIG_H)
+CHECK_INCLUDE_FILES("fastcgi.h" HAVE_FASTCGI_H)
+CHECK_INCLUDE_FILES("fcgiapp.h" FASTCGI_FASTCGI_APP_DIR)
+CHECK_INCLUDE_FILES("fcgimisc.h" HAVE_FASTCGI_MISC_H)
+CHECK_INCLUDE_FILES("fcgio.h" HAVE_FASTCGIO_H)
+CHECK_INCLUDE_FILES("fcgios.h" FASTCGI_FASTCGIOS_DIR)
+CHECK_INCLUDE_FILES("fcgi_stdio.h" HAVE_FASTCGI_STDIO_H)
+CHECK_INCLUDE_FILES("openssl/ssl.h" HAVE_SSL_H)
+CHECK_INCLUDE_FILES("snappy.h" HAVE_SNAPPY_H)
+CHECK_INCLUDE_FILES("uuid/uuid.h" HAVE_UUID_H)
+CHECK_INCLUDE_FILES("atomic_ops.h" HAVE_ATOMIC_OPS)
+CHECK_INCLUDE_FILES("keyutils.h" HAVE_KEYUTILS_H)
+
+include(CheckSymbolExists)
+CHECK_SYMBOL_EXISTS(__u8 "sys/types.h;linux/types.h" HAVE___U8)
+CHECK_SYMBOL_EXISTS(__u64 "sys/types.h;linux/types.h" HAVE___U64)
+CHECK_SYMBOL_EXISTS(__s64 "sys/types.h;linux/types.h" HAVE___S64)
+
+set(CEPH_MAN_DIR "share/man" CACHE STRING "Install location for man pages (relative to prefix).")
+
+option(ENABLE_SHARED "build shared libraries" ON)
+if(${ENABLE_SHARED})
+ set(CEPH_SHARED SHARED)
+else(${ENABLE_SHARED})
+ set(CEPH_SHARED STATIC)
+endif(${ENABLE_SHARED})
+
+find_package(udev REQUIRED)
+set(HAVE_UDEV ${UDEV_FOUND})
+message(STATUS "${UDEV_LIBS}")
+
+option(WITH_AIO "AIO is here ON" ON)
+if(${WITH_AIO})
+find_package(aio REQUIRED)
+set(HAVE_LIBAIO ${AIO_FOUND})
+message(STATUS "${AIO_LIBS}")
+endif(${WITH_AIO})
+
+option(WITH_FUSE "Fuse is here" ON)
+if(${WITH_FUSE})
+find_package(fuse REQUIRED)
+set(HAVE_LIBFUSE ${FUSE_FOUND})
+CHECK_FUNCTION_EXISTS(fuse_getgroups HAVE_FUSE_GETGROUPS)
+endif(${WITH_FUSE})
+
+# probably fuse etc need this -- how to check? XXX
+option(WITH_MDS "MDS is here" ON)
+
+# needs mds and? XXX
+option(WITH_CLIENT "Client is here" ON)
+option(WITH_LIBCEPHFS "libcephfs client library" ON)
+
+# key-value store
+option(WITH_KVS "Key value store is here" ON)
+
+# remote block storage
+option(WITH_RBD "Remote block storage is here" ON)
+if(${WITH_RBD})
+find_package(blkid REQUIRED)
+set(HAVE_LIBBLKID ${BLKID_FOUND})
+endif(${WITH_RBD})
+
+option(WITH_LEVELDB "LevelDB is here" ON)
+if(${WITH_LEVELDB})
+find_package(leveldb REQUIRED)
+set(HAVE_LIBLEVELDB ${LEVELDB_FOUND})
+CHECK_INCLUDE_FILES("leveldb/filter_policy.h" HAVE_LEVELDB_FILTER_POLICY)
+endif(${WITH_LEVELDB})
+
+option(WITH_EXPAT "EXPAT is here" ON)
+if(${WITH_EXPAT})
+find_package(expat REQUIRED)
+set(HAVE_EXPAT ${EXPAT_FOUND})
+endif(${WITH_EXPAT})
+
+option(WITH_FCGI "FCGI is here" ON)
+if(${WITH_FCGI})
+find_package(fcgi REQUIRED)
+set(HAVE_FCGI ${FCGI_FOUND})
+endif(${WITH_FCGI})
+
+option(WITH_ATOMICS_OPS "Atomic Ops is here" ON)
+if(${WITH_ATOMIC_OPS})
+find_package(atomic_ops REQUIRED)
+set(HAVE_ATOMIC_OPS ${ATOMIC_OPS_FOUND})
+endif(${WITH_ATOMIC_OPS})
+
+option(WITH_PROFILER "The Profiler is here" ON)
+if(${WITH_PROFILER})
+find_package(profiler REQUIRED)
+set(HAVE_PROFILER ${PROFILER_FOUND})
+endif(${WITH_PROFILER})
+
+option(WITH_SNAPPY "Snappy is here" ON)
+if(${WITH_SNAPPY})
+find_package(snappy REQUIRED)
+set(HAVE_LIBSNAPPY ${SNAPPY_FOUND})
+endif(${WITH_SNAPPY})
+
+option(WITH_TCMALLOC "Use TCMalloc as Allocator" ON)
+if(${WITH_TCMALLOC})
+find_package(tcmalloc REQUIRED)
+set(HAVE_LIBTCMALLOC ${Tcmalloc_FOUND})
+endif(${WITH_TCMALLOC})
+
+option(USE_CRYPTOPP "Cryptopp is ON" ON)
+find_package(cryptopp)
+if(CRYPTOPP_FOUND)
+ MESSAGE(STATUS "${CRYPTOPP_LIBRARIES}")
+ set(CRYPTO_LIBS ${CRYPTOPP_LIBRARIES})
+ set(USE_NSS 0)
+else()
+ MESSAGE(STATUS "Cryptopp not here using NSS instead")
+ set(USE_NSS 1)
+ MESSAGE(STATUS "${NSS_LIBRARIES}")
+ find_package(NSS)
+ if(NSS_FOUND)
+ MESSAGE(STATUS "${NSS_LIBRARIES}")
+ #It is known to be false why the test
+ if(NOT CRYPTOPP_FOUND)
+ set(CRYPTO_LIBS ${NSS_LIBRARIES})
+ add_definitions(-DUSE_NSS)
+ endif(NOT CRYPTOPP_FOUND)
+ endif(NSS_FOUND)
+endif(CRYPTOPP_FOUND)
+
+option(WITH_XIO "Enable XIO messaging" ON)
+if(WITH_XIO)
+find_package(xio)
+set(HAVE_XIO ${Xio_FOUND})
+endif(WITH_XIO)
+
+#option for RGW
+option(WITH_RADOSGW "Rados Gateway is enabled" ON)
+
+# Now create a useable config.h
+configure_file(
+ ${PROJECT_SOURCE_DIR}/src/include/config-h.in.cmake
+ ${PROJECT_BINARY_DIR}/include/acconfig.h
+)
+include_directories(${PROJECT_BINARY_DIR}/include)
+
+add_definitions(-D__linux__)
+
+if(${ENABLE_SHARED})
+ set(Boost_USE_STATIC_LIBS OFF)
+else(${ENABLE_SHARED})
+ set(Boost_USE_STATIC_LIBS ON)
+endif(${ENABLE_SHARED})
+
+set(Boost_USE_MULTITHREADED ON)
+find_package(Boost COMPONENTS thread system REQUIRED)
+include_directories(${Boost_INCLUDE_DIRS})
+
+find_package(Threads REQUIRED)
+
+# find out which platform we are building on
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ set(LINUX ON)
+ set(UNIX ON)
+ FIND_PACKAGE(Threads)
+endif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+
+# find out which platform we are building on
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+set(OperatingSystem "Mac OS X")
+endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+
+add_subdirectory(src)
+add_subdirectory(man)
--- /dev/null
+Overview
+========
+This is a work in progress Cmake build system. Currently it builds alimited set of targets,
+and only on Linux/posix. The goals include faster builds (see for yourself), cleaner
+builds (no libtool), and improved portability (e.g., Windows).
+
+Building Ceph
+=============
+To build out of source make an empty directory called "build" and run:
+$ cmake [path to top level ceph-local directory]
+
+To build in source make an empty directory called "build" and run:
+$ cmake ..
+
+Once the Configuring is done and the Build files have been written to the current
+build directory run:
+$ make
+
+To build only certain targets type in:
+$ make [target name]
+
+To install, once all the targets are built run:
+$ make install
+
+Options
+=======
+There is an option to build the Rados Gateway that is defaulted to ON
+To build without the Rados Gateway:
+$ cmake [path to top level ceph-local directory] -DWITH_RADOSGW=OFF
+
+To build with debugging and alternate locations for (a couple of)
+external dependencies:
+$ cmake -DLEVELDB_PREFIX="/opt/hyperleveldb" -DOFED_PREFIX="/opt/ofed" \
+ -DCMAKE_INSTALL_PREFIX=/opt/accelio -DCMAKE_C_FLAGS="-O0 -g3 -gdwarf-4" \
+ ..
+
+With future development efforts more options will be implemented
+
+Targets Built
+==============
+ceph-mon
+ceph-osd
+ceph-mds
+cephfs
+ceph-syn
+rados
+radosgw (set ON as a default)
+librados-config
+ceph-conf
+monmaptool
+osdmaptool
+crushtool
+ceph-authtool
+init-ceph
+mkcephfs
+mon_store_converter
+ceph-fuse
+
+Future work will be done to build more targets, check for libraries and headers more thoroughly
+and include tests to make this build become more robust. CMake allows ceph to build onto many
+platforms such as Windows though the shell scripts need bash/unix to run.
+
--- /dev/null
+# - Try to find NSS
+# Once done this will define
+#
+# NSS_FOUND - system has NSS
+# NSS_INCLUDE_DIRS - the NSS include directory
+# NSS_LIBRARIES - Link these to use NSS
+# NSS_DEFINITIONS - Compiler switches required for using NSS
+#
+# Copyright (c) 2010 Andreas Schneider <asn@redhat.com>
+#
+# Redistribution and use is allowed according to the terms of the New
+# BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
+
+
+if (NSS_LIBRARIES AND NSS_INCLUDE_DIRS)
+ # in cache already
+ set(NSS_FOUND TRUE)
+else (NSS_LIBRARIES AND NSS_INCLUDE_DIRS)
+ find_package(PkgConfig)
+ if (PKG_CONFIG_FOUND)
+ pkg_check_modules(_NSS nss)
+ endif (PKG_CONFIG_FOUND)
+
+ find_path(NSS_INCLUDE_DIR
+ NAMES
+ nss.h
+ PATHS
+ ${_NSS_INCLUDEDIR}
+ /usr/include
+ /usr/local/include
+ /opt/local/include
+ /sw/include
+ PATH_SUFFIXES
+ nss3
+ )
+
+ find_library(SSL3_LIBRARY
+ NAMES
+ ssl3
+ PATHS
+ ${_NSS_LIBDIR}
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+ /sw/lib
+ )
+
+ find_library(SMIME3_LIBRARY
+ NAMES
+ smime3
+ PATHS
+ ${_NSS_LIBDIR}
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+ /sw/lib
+ )
+
+ find_library(NSS3_LIBRARY
+ NAMES
+ nss3
+ PATHS
+ ${_NSS_LIBDIR}
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+ /sw/lib
+ /usr/lib/x86_64-linux-gnu
+ )
+
+ find_library(NSSUTIL3_LIBRARY
+ NAMES
+ nssutil3
+ PATHS
+ ${_NSS_LIBDIR}
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+ /sw/lib
+ )
+
+ set(NSS_INCLUDE_DIRS
+ ${NSS_INCLUDE_DIR}
+ )
+
+ if (SSL3_LIBRARY)
+ set(NSS_LIBRARIES
+ ${NSS_LIBRARIES}
+ ${SSL3_LIBRARY}
+ )
+ endif (SSL3_LIBRARY)
+
+ if (SMIME3_LIBRARY)
+ set(NSS_LIBRARIES
+ ${NSS_LIBRARIES}
+ ${SMIME3_LIBRARY}
+ )
+ endif (SMIME3_LIBRARY)
+
+ if (NSS3_LIBRARY)
+ set(NSS_LIBRARIES
+ ${NSS_LIBRARIES}
+ ${NSS3_LIBRARY}
+ )
+ endif (NSS3_LIBRARY)
+
+ if (NSSUTIL3_LIBRARY)
+ set(NSS_LIBRARIES
+ ${NSS_LIBRARIES}
+ ${NSSUTIL3_LIBRARY}
+ )
+ endif (NSSUTIL3_LIBRARY)
+
+ include(FindPackageHandleStandardArgs)
+ find_package_handle_standard_args(NSS DEFAULT_MSG NSS_LIBRARIES NSS_INCLUDE_DIRS)
+
+ # show the NSS_INCLUDE_DIRS and NSS_LIBRARIES variables only in the advanced view
+ mark_as_advanced(NSS_INCLUDE_DIRS NSS_LIBRARIES)
+
+endif (NSS_LIBRARIES AND NSS_INCLUDE_DIRS)
--- /dev/null
+# - Find AIO
+#
+# AIO_INCLUDE - Where to find AIO/aio.h
+# AIO_LIBS - List of libraries when using AIO.
+# AIO_FOUND - True if AIO found.
+
+get_filename_component(module_file_path ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+# Look for the header file.
+find_path(AIO_INCLUDE
+NAMES aio.h
+PATHS /usr/include $ENV{AIO_ROOT}/include /opt/local/include /usr/local/include
+DOC "Path in which the file AIO/aio.h is located." )
+
+mark_as_advanced(AIO_INCLUDE)
+
+# Look for the library.
+# Does this work on UNIX systems? (LINUX)
+find_library(AIO_LIBS
+NAMES aio
+PATHS /usr/lib /usr/lib/x86_64-linux-gnu $ENV{AIO_ROOT}/lib
+DOC "Path to AIO library.")
+
+mark_as_advanced(AIO_LIBS)
+
+# Copy the results to the output variables.
+if (AIO_INCLUDE AND AIO_LIBS)
+ message(STATUS "Found AIO in ${AIO_INCLUDE} ${AIO_LIBS}")
+ set(AIO_FOUND 1)
+ include(CheckCXXSourceCompiles)
+ set(CMAKE_REQUIRED_LIBRARY ${AIO_LIBS} pthread)
+ set(CMAKE_REQUIRED_INCLUDES ${AIO_INCLUDE})
+ else ()
+ set(AIO_FOUND 0)
+ endif ()
+
+ # Report the results.
+ if (NOT AIO_FOUND)
+ set(AIO_DIR_MESSAGE "AIO was not found. Make sure AIO_LIBS and AIO_INCLUDE are set.")
+ if (AIO_FIND_REQUIRED)
+ message(FATAL_ERROR "${AIO_DIR_MESSAGE}")
+ elseif (NOT AIO_FIND_QUIETLY)
+ message(STATUS "${AIO_DIR_MESSAGE}")
+ endif ()
+ endif ()
--- /dev/null
+# - Find atomic_ops
+# Find the native ATOMIC_OPS headers and libraries.
+#
+# ATOMIC_OPS_INCLUDE_DIRS - where to find atomic_ops.h, etc.
+# ATOMIC_OPS_LIBRARIES - List of libraries when using atomic_ops.
+# ATOMIC_OPS_FOUND - True if atomic_ops found.
+
+# Look for the header file.
+FIND_PATH(ATOMIC_OPS_INCLUDE_DIR NAMES atomic_ops.h)
+
+# Look for the library.
+FIND_LIBRARY(ATOMIC_OPS_LIBRARY NAMES atomic_ops)
+
+# handle the QUIETLY and REQUIRED arguments and set ATOMIC_OPS_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ATOMIC_OPS DEFAULT_MSG ATOMIC_OPS_LIBRARY ATOMIC_OPS_INCLUDE_DIR)
+
+# Copy the results to the output variables.
+IF(ATOMIC_OPS_FOUND)
+ SET(ATOMIC_OPS_LIBRARIES ${ATOMIC_OPS_LIBRARY})
+ SET(ATOMIC_OPS_INCLUDE_DIRS ${ATOMIC_OPS_INCLUDE_DIR})
+ELSE(ATOMIC_OPS_FOUND)
+ SET(ATOMIC_OPS_LIBRARIES)
+ SET(ATOMIC_OPS_INCLUDE_DIRS)
+ENDIF(ATOMIC_OPS_FOUND)
+
+MARK_AS_ADVANCED(ATOMIC_OPS_INCLUDE_DIR ATOMIC_OPS_LIBRARY)
--- /dev/null
+# Copyright (C) 2007-2012 Hypertable, Inc.
+#
+# This file is part of Hypertable.
+#
+# Hypertable 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 any later version.
+#
+# Hypertable 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 Hypertable. If not, see <http://www.gnu.org/licenses/>
+#
+
+# - Find libblkid
+# Find the blkid library and includes
+#
+# BLKID_INCLUDE_DIR - where to find blkid.h, etc.
+# BLKID_LIBRARIES - List of libraries when using blkid.
+# BLKID_FOUND - True if blkid found.
+
+find_path(BLKID_INCLUDE_DIR blkid/blkid.h)
+
+set(BLKID_NAMES ${BLKID_NAMES} blkid)
+find_library(BLKID_LIBRARY NAMES ${BLKID_NAMES})
+
+if (BLKID_INCLUDE_DIR AND BLKID_LIBRARY)
+ set(BLKID_FOUND TRUE)
+ set( BLKID_LIBRARIES ${BLKID_LIBRARY} )
+else ()
+ set(BLKID_FOUND FALSE)
+ set( BLKID_LIBRARIES )
+endif ()
+
+if (BLKID_FOUND)
+ message(STATUS "Found libblkid: ${BLKID_LIBRARY}")
+else ()
+ message(STATUS "Not Found libblkid: ${BLKID_LIBRARY}")
+ if (BLKID_FIND_REQUIRED)
+ message(STATUS "Looked for libblkid named ${BLKID_NAMES}.")
+ message(FATAL_ERROR "Could NOT find libblkid")
+ endif ()
+endif ()
+
+mark_as_advanced(
+ BLKID_LIBRARY
+ BLKID_I
+)
--- /dev/null
+# - Find cds
+#
+# CDS_INCLUDE_DIR - where to find cds/init.h
+# FIO_FOUND - True if found.
+
+find_path(CDS_INC_DIR cds/init.h NO_DEFAULT_PATH PATHS
+ /usr/include
+ /opt/local/include
+ /usr/local/include
+ /opt/cds
+)
+
+if (CDS_INC_DIR)
+ set(CDS_FOUND TRUE)
+else ()
+ set(CDS_FOUND FALSE)
+endif ()
+
+if (CDS_FOUND)
+ message(STATUS "Found cds: ${CDS_INC_DIR}")
+else ()
+ message(STATUS "Failed to find cds/init.h")
+ if (CDS_FIND_REQUIRED)
+ message(FATAL_ERROR "Missing required cds/init.h")
+ endif ()
+endif ()
+
+find_library(CDS_LIBS
+ NAMES cds
+ PATHS /usr/lib /usr/lib/x86_64-linux-gnu /opt/cds/bin/gcc-amd64-linux-64
+)
+
+mark_as_advanced(
+ CDS_INC_DIR
+ CDS_LIBS
+)
+
--- /dev/null
+# Module for locating the Crypto++ encryption library.
+#
+# Customizable variables:
+# CRYPTOPP_ROOT_DIR
+# This variable points to the CryptoPP root directory. On Windows the
+# library location typically will have to be provided explicitly using the
+# -D command-line option. The directory should include the include/cryptopp,
+# lib and/or bin sub-directories.
+#
+# Read-only variables:
+# CRYPTOPP_FOUND
+# Indicates whether the library has been found.
+#
+# CRYPTOPP_INCLUDE_DIRS
+# Points to the CryptoPP include directory.
+#
+# CRYPTOPP_LIBRARIES
+# Points to the CryptoPP libraries that should be passed to
+# target_link_libararies.
+#
+#
+# Copyright (c) 2012 Sergiu Dotenco
+#
+# 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.
+
+INCLUDE (FindPackageHandleStandardArgs)
+
+FIND_PATH (CRYPTOPP_ROOT_DIR
+ NAMES cryptopp/cryptlib.h include/cryptopp/cryptlib.h
+ PATHS ENV CRYPTOPPROOT
+ DOC "CryptoPP root directory")
+
+# Re-use the previous path:
+FIND_PATH (CRYPTOPP_INCLUDE_DIR
+ NAMES cryptopp/cryptlib.h
+ HINTS ${CRYPTOPP_ROOT_DIR}
+ PATH_SUFFIXES include
+ DOC "CryptoPP include directory")
+
+FIND_LIBRARY (CRYPTOPP_LIBRARY_DEBUG
+ NAMES cryptlibd cryptoppd
+ HINTS ${CRYPTOPP_ROOT_DIR}
+ PATH_SUFFIXES lib
+ DOC "CryptoPP debug library")
+
+FIND_LIBRARY (CRYPTOPP_LIBRARY_RELEASE
+ NAMES cryptlib cryptopp
+ HINTS ${CRYPTOPP_ROOT_DIR}
+ PATH_SUFFIXES lib
+ DOC "CryptoPP release library")
+
+IF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE)
+ SET (CRYPTOPP_LIBRARY
+ optimized ${CRYPTOPP_LIBRARY_RELEASE}
+ debug ${CRYPTOPP_LIBRARY_DEBUG} CACHE DOC "CryptoPP library")
+ELSEIF (CRYPTOPP_LIBRARY_RELEASE)
+ SET (CRYPTOPP_LIBRARY ${CRYPTOPP_LIBRARY_RELEASE} CACHE DOC
+ "CryptoPP library")
+ENDIF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE)
+
+IF (CRYPTOPP_INCLUDE_DIR)
+ SET (_CRYPTOPP_VERSION_HEADER ${CRYPTOPP_INCLUDE_DIR}/cryptopp/config.h)
+
+ IF (EXISTS ${_CRYPTOPP_VERSION_HEADER})
+ FILE (STRINGS ${_CRYPTOPP_VERSION_HEADER} _CRYPTOPP_VERSION_TMP REGEX
+ "^#define CRYPTOPP_VERSION[ \t]+[0-9]+$")
+
+ STRING (REGEX REPLACE
+ "^#define CRYPTOPP_VERSION[ \t]+([0-9]+)" "\\1" _CRYPTOPP_VERSION_TMP
+ ${_CRYPTOPP_VERSION_TMP})
+
+ STRING (REGEX REPLACE "([0-9]+)[0-9][0-9]" "\\1" CRYPTOPP_VERSION_MAJOR
+ ${_CRYPTOPP_VERSION_TMP})
+ STRING (REGEX REPLACE "[0-9]([0-9])[0-9]" "\\1" CRYPTOPP_VERSION_MINOR
+ ${_CRYPTOPP_VERSION_TMP})
+ STRING (REGEX REPLACE "[0-9][0-9]([0-9])" "\\1" CRYPTOPP_VERSION_PATCH
+ ${_CRYPTOPP_VERSION_TMP})
+
+ SET (CRYPTOPP_VERSION_COUNT 3)
+ SET (CRYPTOPP_VERSION
+ ${CRYPTOPP_VERSION_MAJOR}.${CRYPTOPP_VERSION_MINOR}.${CRYPTOPP_VERSION_PATCH})
+ ENDIF (EXISTS ${_CRYPTOPP_VERSION_HEADER})
+ENDIF (CRYPTOPP_INCLUDE_DIR)
+
+SET (CRYPTOPP_INCLUDE_DIRS ${CRYPTOPP_INCLUDE_DIR})
+SET (CRYPTOPP_LIBRARIES ${CRYPTOPP_LIBRARY})
+
+MARK_AS_ADVANCED (CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY CRYPTOPP_LIBRARY_DEBUG
+ CRYPTOPP_LIBRARY_RELEASE)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS (CryptoPP REQUIRED_VARS CRYPTOPP_ROOT_DIR
+ CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY VERSION_VAR CRYPTOPP_VERSION)
--- /dev/null
+# - Find expat
+# Find the native EXPAT headers and libraries.
+#
+# EXPAT_INCLUDE_DIRS - where to find expat.h, etc.
+# EXPAT_LIBRARIES - List of libraries when using expat.
+# EXPAT_FOUND - True if expat found.
+
+# Look for the header file.
+FIND_PATH(EXPAT_INCLUDE_DIR NAMES expat.h)
+
+# Look for the library.
+FIND_LIBRARY(EXPAT_LIBRARY NAMES expat)
+
+# handle the QUIETLY and REQUIRED arguments and set EXPAT_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(EXPAT DEFAULT_MSG EXPAT_LIBRARY EXPAT_INCLUDE_DIR)
+
+# Copy the results to the output variables.
+IF(EXPAT_FOUND)
+ SET(EXPAT_LIBRARIES ${EXPAT_LIBRARY})
+ SET(EXPAT_INCLUDE_DIRS ${EXPAT_INCLUDE_DIR})
+ELSE(EXPAT_FOUND)
+ SET(EXPAT_LIBRARIES)
+ SET(EXPAT_INCLUDE_DIRS)
+ENDIF(EXPAT_FOUND)
+
+MARK_AS_ADVANCED(EXPAT_INCLUDE_DIR EXPAT_LIBRARY)
+
--- /dev/null
+# CMake module to search for FastCGI headers
+#
+# If it's found it sets FCGI_FOUND to TRUE
+# and following variables are set:
+# FCGI_INCLUDE_DIR
+# FCGI_LIBRARY
+FIND_PATH(FCGI_INCLUDE_DIR
+ fcgio.h
+ PATHS
+ /usr/include
+ /usr/local/include
+ /usr/include/fastcgi
+ "$ENV{LIB_DIR}/include"
+ $ENV{INCLUDE}
+ )
+FIND_LIBRARY(FCGI_LIBRARY NAMES fcgi libfcgi PATHS
+ /usr/local/lib
+ /usr/lib
+ "$ENV{LIB_DIR}/lib"
+ "$ENV{LIB}"
+ )
+
+IF (FCGI_INCLUDE_DIR AND FCGI_LIBRARY)
+ SET(FCGI_FOUND TRUE)
+ENDIF (FCGI_INCLUDE_DIR AND FCGI_LIBRARY)
+
+IF (FCGI_FOUND)
+ IF (NOT FCGI_FIND_QUIETLY)
+ MESSAGE(STATUS "Found FCGI: ${FCGI_LIBRARY}")
+ ENDIF (NOT FCGI_FIND_QUIETLY)
+ELSE (FCGI_FOUND)
+ IF (FCGI_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find FCGI")
+ ENDIF (FCGI_FIND_REQUIRED)
+ENDIF (FCGI_FOUND)
--- /dev/null
+# - Find fio
+#
+# FIO_INCLUDE_DIR - where to find fio.h
+# FIO_FOUND - True if found.
+
+find_path(FIO_INCLUDE_DIR fio.h NO_DEFAULT_PATH PATHS
+ /usr/include
+ /opt/local/include
+ /usr/local/include
+)
+
+if (FIO_INCLUDE_DIR)
+ set(FIO_FOUND TRUE)
+else ()
+ set(FIO_FOUND FALSE)
+endif ()
+
+if (FIO_FOUND)
+ message(STATUS "Found fio: ${FIO_INCLUDE_DIR}")
+else ()
+ message(STATUS "Failed to find fio.h")
+ if (FIO_FIND_REQUIRED)
+ message(FATAL_ERROR "Missing required fio.h")
+ endif ()
+endif ()
+
+mark_as_advanced(
+ FIO_INCLUDE_DIR
+)
--- /dev/null
+# This module can find FUSE Library
+#
+# Requirements:
+# - CMake >= 2.8.3
+#
+# The following variables will be defined for your use:
+# - FUSE_FOUND : was FUSE found?
+# - FUSE_INCLUDE_DIRS : FUSE include directory
+# - FUSE_LIBRARIES : FUSE library
+# - FUSE_DEFINITIONS : FUSE cflags
+# - FUSE_VERSION : complete version of FUSE (major.minor)
+# - FUSE_MAJOR_VERSION : major version of FUSE
+# - FUSE_MINOR_VERSION : minor version of FUSE
+#
+# Example Usage:
+#
+# 1. Copy this file in the root of your project source directory
+# 2. Then, tell CMake to search this non-standard module in your project directory by adding to your CMakeLists.txt:
+# set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR})
+# 3. Finally call find_package() once, here are some examples to pick from
+#
+# Require FUSE 2.6 or later
+# find_package(FUSE 2.6 REQUIRED)
+#
+# if(FUSE_FOUND)
+# add_definitions(${FUSE_DEFINITIONS})
+# include_directories(${FUSE_INCLUDE_DIRS})
+# add_executable(myapp myapp.c)
+# target_link_libraries(myapp ${FUSE_LIBRARIES})
+# endif()
+
+#=============================================================================
+# Copyright (c) 2012, julp
+#
+# Distributed under the OSI-approved BSD License
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#=============================================================================
+
+cmake_minimum_required(VERSION 2.8.3)
+
+########## Private ##########
+function(fusedebug _varname)
+ if(FUSE_DEBUG)
+ message("${_varname} = ${${_varname}}")
+ endif(FUSE_DEBUG)
+endfunction(fusedebug)
+
+########## Public ##########
+set(FUSE_FOUND TRUE)
+set(FUSE_LIBRARIES )
+set(FUSE_DEFINITIONS )
+set(FUSE_INCLUDE_DIRS )
+
+find_package(PkgConfig)
+
+set(PC_FUSE_INCLUDE_DIRS )
+set(PC_FUSE_LIBRARY_DIRS )
+if(PKG_CONFIG_FOUND)
+ pkg_check_modules(PC_FUSE "fuse" QUIET)
+ if(PC_FUSE_FOUND)
+# fusedebug(PC_FUSE_LIBRARIES)
+# fusedebug(PC_FUSE_LIBRARY_DIRS)
+# fusedebug(PC_FUSE_LDFLAGS)
+# fusedebug(PC_FUSE_LDFLAGS_OTHER)
+# fusedebug(PC_FUSE_INCLUDE_DIRS)
+# fusedebug(PC_FUSE_CFLAGS)
+# fusedebug(PC_FUSE_CFLAGS_OTHER)
+ set(FUSE_DEFINITIONS "${PC_FUSE_CFLAGS_OTHER}")
+ endif(PC_FUSE_FOUND)
+endif(PKG_CONFIG_FOUND)
+
+find_path(
+ FUSE_INCLUDE_DIRS
+ NAMES fuse.h
+ PATHS "${PC_FUSE_INCLUDE_DIRS}"
+ DOC "Include directories for FUSE"
+)
+
+if(NOT FUSE_INCLUDE_DIRS)
+ set(FUSE_FOUND FALSE)
+endif(NOT FUSE_INCLUDE_DIRS)
+
+find_library(
+ FUSE_LIBRARIES
+ NAMES "fuse"
+ PATHS "${PC_FUSE_LIBRARY_DIRS}"
+ DOC "Libraries for FUSE"
+)
+
+if(NOT FUSE_LIBRARIES)
+ set(FUSE_FOUND FALSE)
+endif(NOT FUSE_LIBRARIES)
+
+if(FUSE_FOUND)
+ if(EXISTS "${FUSE_INCLUDE_DIRS}/fuse/fuse_common.h")
+ file(READ "${FUSE_INCLUDE_DIRS}/fuse/fuse_common.h" _contents)
+ string(REGEX REPLACE ".*# *define *FUSE_MAJOR_VERSION *([0-9]+).*" "\\1" FUSE_MAJOR_VERSION "${_contents}")
+ string(REGEX REPLACE ".*# *define *FUSE_MINOR_VERSION *([0-9]+).*" "\\1" FUSE_MINOR_VERSION "${_contents}")
+ set(FUSE_VERSION "${FUSE_MAJOR_VERSION}.${FUSE_MINOR_VERSION}")
+ endif()
+
+ include(CheckCSourceCompiles)
+ # Backup CMAKE_REQUIRED_*
+ set(OLD_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}")
+ set(OLD_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
+ set(OLD_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}")
+ # Add FUSE compilation flags
+ set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}" "${FUSE_INCLUDE_DIRS}")
+ set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}" "${FUSE_LIBRARIES}")
+ set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}" "${FUSE_DEFINITIONS}")
+ check_c_source_compiles("#include <stdlib.h>
+#include <fuse.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+
+int main(void) {
+return 0;
+}" FUSE_CFLAGS_CHECK)
+ if(NOT FUSE_CFLAGS_CHECK)
+ set(FUSE_DEFINITIONS "-D_FILE_OFFSET_BITS=64")
+ # Should we run again previous test to assume the failure was due to missing definition -D_FILE_OFFSET_BITS=64?
+ endif(NOT FUSE_CFLAGS_CHECK)
+ # Restore CMAKE_REQUIRED_*
+ set(CMAKE_REQUIRED_INCLUDES "${OLD_CMAKE_REQUIRED_INCLUDES}")
+ set(CMAKE_REQUIRED_LIBRARIES "${OLD_CMAKE_REQUIRED_LIBRARIES}")
+ set(CMAKE_REQUIRED_DEFINITIONS "${OLD_CMAKE_REQUIRED_DEFINITIONS}")
+endif(FUSE_FOUND)
+
+if(FUSE_INCLUDE_DIRS)
+ include(FindPackageHandleStandardArgs)
+ if(FUSE_FIND_REQUIRED AND NOT FUSE_FIND_QUIETLY)
+ find_package_handle_standard_args(FUSE REQUIRED_VARS FUSE_LIBRARIES FUSE_INCLUDE_DIRS VERSION_VAR FUSE_VERSION)
+ else()
+ find_package_handle_standard_args(FUSE "FUSE not found" FUSE_LIBRARIES FUSE_INCLUDE_DIRS)
+ endif()
+else(FUSE_INCLUDE_DIRS)
+ if(FUSE_FIND_REQUIRED AND NOT FUSE_FIND_QUIETLY)
+ message(FATAL_ERROR "Could not find FUSE include directory")
+ endif()
+endif(FUSE_INCLUDE_DIRS)
+
+mark_as_advanced(
+ FUSE_INCLUDE_DIRS
+ FUSE_LIBRARIES
+)
+
+# IN (args)
+fusedebug("FUSE_FIND_COMPONENTS")
+fusedebug("FUSE_FIND_REQUIRED")
+fusedebug("FUSE_FIND_QUIETLY")
+fusedebug("FUSE_FIND_VERSION")
+# OUT
+# Found
+fusedebug("FUSE_FOUND")
+# Definitions
+fusedebug("FUSE_DEFINITIONS")
+# Linking
+fusedebug("FUSE_INCLUDE_DIRS")
+fusedebug("FUSE_LIBRARIES")
+# Version
+fusedebug("FUSE_MAJOR_VERSION")
+fusedebug("FUSE_MINOR_VERSION")
+fusedebug("FUSE_VERSION")
--- /dev/null
+# - Find LevelDB
+#
+# LEVELDB_INCLUDE - Where to find leveldb/db.h
+# LEVELDB_LIBS - List of libraries when using LevelDB.
+# LEVELDB_FOUND - True if LevelDB found.
+
+get_filename_component(module_file_path ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+# Look for the header file.
+find_path(LEVELDB_INCLUDE NAMES leveldb/db.h PATHS $ENV{LEVELDB_ROOT}/include /opt/local/include /usr/local/include /usr/include DOC "Path in which the file leveldb/db.h is located." )
+mark_as_advanced(LEVELDB_INCLUDE)
+
+# Look for the library.
+# Does this work on UNIX systems? (LINUX)
+find_library(LEVELDB_LIBS NAMES leveldb PATHS /usr/lib $ENV{LEVELDB_ROOT}/lib DOC "Path to leveldb library." )
+mark_as_advanced(LEVELDB_LIBS)
+
+# Copy the results to the output variables.
+if (LEVELDB_INCLUDE AND LEVELDB_LIBS)
+ message(STATUS "Found leveldb in ${LEVELDB_INCLUDE} ${LEVELDB_LIBS}")
+ set(LEVELDB_FOUND 1)
+ include(CheckCXXSourceCompiles)
+ set(CMAKE_REQUIRED_LIBRARY ${LEVELDB_LIBS} pthread)
+ set(CMAKE_REQUIRED_INCLUDES ${LEVELDB_INCLUDE})
+ else ()
+ set(LEVELDB_FOUND 0)
+ endif ()
+
+ # Report the results.
+ if (NOT LEVELDB_FOUND)
+ set(LEVELDB_DIR_MESSAGE "LEVELDB was not found. Make sure LEVELDB_LIBS and LEVELDB_INCLUDE are set.")
+ if (LEVELDB_FIND_REQUIRED)
+ message(FATAL_ERROR "${LEVELDB_DIR_MESSAGE}")
+ elseif (NOT LEVELDB_FIND_QUIETLY)
+ message(STATUS "${LEVELDB_DIR_MESSAGE}")
+ endif ()
+ endif ()
--- /dev/null
+# Try to find Profiler
+# Once done, this will define
+#
+# PROFILER_FOUND - system has Profiler
+# PROFILER_INCLUDE_DIR - the Profiler include directories
+# PROFILER_LIBRARIES - link these to use Profiler
+
+if(PROFILER_INCLUDE_DIR AND PROFILER_LIBRARIES)
+set(PROFILER_FIND_QUIETLY TRUE)
+endif(PROFILER_INCLUDE_DIR AND PROFILER_LIBRARIES)
+
+INCLUDE(CheckCXXSymbolExists)
+
+# include dir
+
+find_path(PROFILER_INCLUDE_DIR profiler.h NO_DEFAULT_PATH PATHS
+ ${HT_DEPENDENCY_INCLUDE_DIR}
+ /usr/include
+ /usr/include/google
+ /opt/local/include
+ /usr/local/include
+)
+
+
+# finally the library itself
+find_library(LIBPROFILER NAMES profiler)
+set(PROFILER_LIBRARIES ${LIBPROFILER})
+
+# handle the QUIETLY and REQUIRED arguments and set PROFILER_FOUND to TRUE if
+# all listed variables are TRUE
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PROFILER DEFAULT_MSG PROFILER_LIBRARIES PROFILER_INCLUDE_DIR)
+
+mark_as_advanced(PROFILER_LIBRARIES PROFILER_INCLUDE_DIR)
--- /dev/null
+# Copyright (C) 2007-2012 Hypertable, Inc.
+#
+# This file is part of Hypertable.
+#
+# Hypertable 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 any later version.
+#
+# Hypertable 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 Hypertable. If not, see <http://www.gnu.org/licenses/>
+#
+
+# - Find Snappy
+# Find the snappy compression library and includes
+#
+# SNAPPY_INCLUDE_DIR - where to find snappy.h, etc.
+# SNAPPY_LIBRARIES - List of libraries when using snappy.
+# SNAPPY_FOUND - True if snappy found.
+
+find_path(SNAPPY_INCLUDE_DIR snappy.h NO_DEFAULT_PATH PATHS
+ ${HT_DEPENDENCY_INCLUDE_DIR}
+ /usr/include
+ /opt/local/include
+ /usr/local/include
+)
+
+set(SNAPPY_NAMES ${SNAPPY_NAMES} snappy)
+find_library(SNAPPY_LIBRARY NAMES ${SNAPPY_NAMES} NO_DEFAULT_PATH PATHS
+ ${HT_DEPENDENCY_LIB_DIR}
+ /usr/local/lib
+ /opt/local/lib
+ /usr/lib
+ )
+
+if (SNAPPY_INCLUDE_DIR AND SNAPPY_LIBRARY)
+ set(SNAPPY_FOUND TRUE)
+ set( SNAPPY_LIBRARIES ${SNAPPY_LIBRARY} )
+else ()
+ set(SNAPPY_FOUND FALSE)
+ set( SNAPPY_LIBRARIES )
+endif ()
+
+if (SNAPPY_FOUND)
+ message(STATUS "Found Snappy: ${SNAPPY_LIBRARY}")
+else ()
+ message(STATUS "Not Found Snappy: ${SNAPPY_LIBRARY}")
+ if (SNAPPY_FIND_REQUIRED)
+ message(STATUS "Looked for Snappy libraries named ${SNAPPY_NAMES}.")
+ message(FATAL_ERROR "Could NOT find Snappy library")
+ endif ()
+endif ()
+
+mark_as_advanced(
+ SNAPPY_LIBRARY
+ SNAPPY_I
+)
--- /dev/null
+# - Find Tcmalloc
+# Find the native Tcmalloc includes and library
+#
+# Tcmalloc_INCLUDE_DIR - where to find Tcmalloc.h, etc.
+# Tcmalloc_LIBRARIES - List of libraries when using Tcmalloc.
+# Tcmalloc_FOUND - True if Tcmalloc found.
+
+find_path(Tcmalloc_INCLUDE_DIR google/tcmalloc.h NO_DEFAULT_PATH PATHS
+ ${HT_DEPENDENCY_INCLUDE_DIR}
+ /usr/include
+ /opt/local/include
+ /usr/local/include
+)
+
+if (USE_TCMALLOC)
+ set(Tcmalloc_NAMES tcmalloc)
+else ()
+ set(Tcmalloc_NAMES tcmalloc_minimal tcmalloc)
+endif ()
+
+find_library(Tcmalloc_LIBRARY NO_DEFAULT_PATH
+ NAMES ${Tcmalloc_NAMES}
+ PATHS ${HT_DEPENDENCY_LIB_DIR} /lib /usr/lib /usr/local/lib /opt/local/lib
+)
+
+if (Tcmalloc_INCLUDE_DIR AND Tcmalloc_LIBRARY)
+ set(Tcmalloc_FOUND TRUE)
+ set( Tcmalloc_LIBRARIES ${Tcmalloc_LIBRARY} )
+else ()
+ set(Tcmalloc_FOUND FALSE)
+ set( Tcmalloc_LIBRARIES )
+endif ()
+
+if (Tcmalloc_FOUND)
+ message(STATUS "Found Tcmalloc: ${Tcmalloc_LIBRARY}")
+else ()
+ message(STATUS "Not Found Tcmalloc: ${Tcmalloc_LIBRARY}")
+ if (Tcmalloc_FIND_REQUIRED)
+ message(STATUS "Looked for Tcmalloc libraries named ${Tcmalloc_NAMES}.")
+ message(FATAL_ERROR "Could NOT find Tcmalloc library")
+ endif ()
+endif ()
+
+mark_as_advanced(
+ Tcmalloc_LIBRARY
+ Tcmalloc_INCLUDE_DIR
+ )
--- /dev/null
+# Copyright (C) 2007-2012 Hypertable, Inc.
+#
+# This file is part of Hypertable.
+#
+# Hypertable 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 any later version.
+#
+# Hypertable 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 Hypertable. If not, see <http://www.gnu.org/licenses/>
+#
+
+# - Find libudev
+# Find the udev library and includes
+#
+# UDEV_INCLUDE_DIR - where to find libudev.h, etc.
+# UDEV_LIBRARIES - List of libraries when using udev.
+# UDEV_FOUND - True if udev found.
+
+find_path(UDEV_INCLUDE_DIR libudev.h)
+
+set(UDEV_NAMES ${UDEV_NAMES} udev)
+find_library(UDEV_LIBRARY NAMES ${UDEV_NAMES})
+
+if(UDEV_INCLUDE_DIR AND UDEV_LIBRARY)
+ set(UDEV_FOUND TRUE)
+ set(UDEV_LIBRARIES ${UDEV_LIBRARY})
+else()
+ set(UDEV_FOUND FALSE)
+ set(UDEV_LIBRARIES)
+endif()
+
+if(UDEV_FOUND)
+ message(STATUS "Found libudev: ${UDEV_LIBRARY}")
+else()
+ message(STATUS "Not Found libudev: ${UDEV_LIBRARY}")
+ if(UDEV_FIND_REQUIRED)
+ message(STATUS "Looked for libudev named ${UDEV_NAMES}.")
+ message(FATAL_ERROR "Could NOT find libudev")
+ endif()
+endif()
+
+mark_as_advanced(
+ UDEV_LIBRARY
+ UDEV_I
+)
--- /dev/null
+# - Find libxio
+# Find libxio transport library
+#
+# Xio_INCLUDE_DIR - libxio include dir
+# Xio_LIBRARIES - List of libraries
+# Xio_FOUND - True if libxio found.
+
+set(_xio_include_path ${HT_DEPENDENCY_INCLUDE_DIR})
+set(_xio_lib_path ${HT_DEPENDENCY_LIB_DIR})
+if (EXISTS ${WITH_XIO})
+ list(APPEND _xio_include_path "${WITH_XIO}/include")
+ list(APPEND _xio_lib_path "${WITH_XIO}/lib")
+else()
+ list(APPEND _xio_include_path /usr/include /usr/local/include /opt/accelio/include)
+ list(APPEND _xio_lib_path /lib /usr/lib /usr/local/lib /opt/accelio/lib)
+endif()
+
+find_path(Xio_INCLUDE_DIR libxio.h NO_DEFAULT_PATH PATHS ${_xio_include_path})
+
+find_library(Xio_LIBRARY NO_DEFAULT_PATH NAMES xio PATHS ${_xio_lib_path})
+
+if (Xio_INCLUDE_DIR AND Xio_LIBRARY)
+ set(Xio_FOUND TRUE)
+ set(Xio_LIBRARIES ${Xio_LIBRARY} )
+else ()
+ set(Xio_FOUND FALSE)
+ set(Xio_LIBRARIES )
+endif ()
+
+if (Xio_FOUND)
+ message(STATUS "Found Xio: ${Xio_INCLUDE_DIR} ${Xio_LIBRARY}")
+else ()
+ message(STATUS "Not Found Xio: ${Xio_INCLUDE_DIR} ${Xio_LIBRARY}")
+ if (Xio_FIND_REQUIRED)
+ message(STATUS "Looked for Xio libraries named ${Xio_NAMES}.")
+ message(FATAL_ERROR "Could NOT find Xio library")
+ endif ()
+endif ()
+
+mark_as_advanced(
+ Xio_LIBRARY
+ Xio_INCLUDE_DIR
+ )
--- /dev/null
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+# get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+# git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+# git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+ return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+function(get_git_head_revision _refspecvar _hashvar)
+ set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+ set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+ while(NOT EXISTS "${GIT_DIR}") # .git dir not found, search parent directories
+ set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
+ get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
+ if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
+ # We have reached the root directory, we are not in git
+ set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+ set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+ return()
+ endif()
+ set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+ endwhile()
+ # check if this is a submodule
+ if(NOT IS_DIRECTORY ${GIT_DIR})
+ file(READ ${GIT_DIR} submodule)
+ string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule})
+ get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH)
+ get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE)
+ endif()
+ set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+ if(NOT EXISTS "${GIT_DATA}")
+ file(MAKE_DIRECTORY "${GIT_DATA}")
+ endif()
+
+ if(NOT EXISTS "${GIT_DIR}/HEAD")
+ return()
+ endif()
+ set(HEAD_FILE "${GIT_DATA}/HEAD")
+ configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
+
+ configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+ "${GIT_DATA}/grabRef.cmake"
+ @ONLY)
+ include("${GIT_DATA}/grabRef.cmake")
+
+ set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
+ set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+ if(NOT GIT_FOUND)
+ find_package(Git QUIET)
+ endif()
+ get_git_head_revision(refspec hash)
+ if(NOT GIT_FOUND)
+ set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
+ return()
+ endif()
+ if(NOT hash)
+ set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
+ return()
+ endif()
+
+ # TODO sanitize
+ #if((${ARGN}" MATCHES "&&") OR
+ # (ARGN MATCHES "||") OR
+ # (ARGN MATCHES "\\;"))
+ # message("Please report the following error to the project!")
+ # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+ #endif()
+
+ #message(STATUS "Arguments to execute_process: ${ARGN}")
+
+ execute_process(COMMAND
+ "${GIT_EXECUTABLE}"
+ describe
+ ${hash}
+ ${ARGN}
+ WORKING_DIRECTORY
+ "${CMAKE_SOURCE_DIR}"
+ RESULT_VARIABLE
+ res
+ OUTPUT_VARIABLE
+ out
+ ERROR_QUIET
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+ if(NOT res EQUAL 0)
+ set(out "${out}-${res}-NOTFOUND")
+ endif()
+
+ set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
+
+function(git_get_exact_tag _var)
+ git_describe(out --exact-match ${ARGN})
+ set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
--- /dev/null
+#
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+ # named branch
+ string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+ if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+ configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+ elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
+ configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+ set(HEAD_HASH "${HEAD_REF}")
+ endif()
+else()
+ # detached HEAD
+ configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+ file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+ string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()
--- /dev/null
+install(FILES
+ ceph-osd.8
+ ceph-mds.8
+ ceph-mon.8
+ ceph-fuse.8
+ ceph-syn.8
+ crushtool.8
+ osdmaptool.8
+ monmaptool.8
+ ceph-conf.8
+ ceph-run.8
+ ceph.8
+ mount.ceph.8
+ radosgw.8
+ radosgw-admin.8
+ ceph-authtool.8
+ rados.8
+ librados-config.8
+ rbd.8
+ ceph-clsinfo.8
+ ceph-debugpack.8
+ cephfs.8
+ ceph-dencoder.8
+ ceph-rest-api.8
+ ceph-rbdnamer.8
+ ceph-post-file.8
+ rbd-fuse.8
+ rbd-replay.8
+ rbd-replay-prep.8
+ DESTINATION ${CEPH_MAN_DIR}/man8)
--- /dev/null
+include(GetGitRevisionDescription)
+
+set(bindir ${CMAKE_INSTALL_PREFIX}/bin)
+set(sbindir ${CMAKE_INSTALL_PREFIX}/sbin)
+set(libdir ${CMAKE_INSTALL_PREFIX}/lib)
+set(sysconfdir ${CMAKE_INSTALL_PREFIX}/etc)
+set(pkgdatadir ${CMAKE_INSTALL_PREFIX}/share)
+set(prefix ${CMAKE_INSTALL_PREFIX})
+
+add_definitions("-DCEPH_LIBDIR=\"${libdir}\"")
+add_definitions("-DCEPH_PKGLIBDIR=\"${libdir}\"")
+add_definitions("-DHAVE_CONFIG_H -D__CEPH__ -D_FILE_OFFSET_BITS=64 -D_REENTRANT -D_THREAD_SAFE -D__STDC_FORMAT_MACROS -D_GNU_SOURCE")
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -rdynamic -Wall -Wtype-limits -Wignored-qualifiers -Winit-self -Wpointer-arith -Werror=format-security -fno-strict-aliasing -fsigned-char -fPIC")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -ftemplate-depth-1024 -Wno-invalid-offsetof -Wnon-virtual-dtor -Wno-invalid-offsetof -Wstrict-null-sentinel -Woverloaded-virtual")
+
+set(EXTRALIBS uuid rt dl)
+
+if(${WITH_PROFILER})
+ list(APPEND EXTRALIBS profiler)
+endif(${WITH_PROFILER})
+
+if(WITH_CDS)
+ list(APPEND EXTRALIBS ${CDS_LIBS})
+endif(WITH_CDS)
+
+set(CRYPTO_LIBS cryptopp)
+
+if(${HAVE_ATOMIC_OPS})
+ set(EXTRALIBS
+ atomic_ops
+ ${EXTRALIBS})
+endif(${HAVE_ATOMIC_OPS})
+
+set(GCOV_PREFIX_STRIP 4)
+
+get_git_head_revision(GIT_REFSPEC CEPH_GIT_VER)
+git_describe(CEPH_GIT_NICE_VER --always)
+
+# Python stuff
+find_package(PythonInterp 2 QUIET)
+if(NOT PYTHONINTERP_FOUND)
+ message(FATAL_ERROR "Python 2 interpreter not found.")
+endif(NOT PYTHONINTERP_FOUND)
+
+# if CMAKE_INSTALL_PREFIX is an empty string, must replace
+# it with "/" to make PYTHON_INSTALL_TEMPLATE an absolute path to be
+# consistent with all other installation paths.
+if(CMAKE_INSTALL_PREFIX)
+ set(PYTHON_INSTALL_TEMPLATE "${CMAKE_INSTALL_PREFIX}")
+else(CMAKE_INSTALL_PREFIX)
+ set(PYTHON_INSTALL_TEMPLATE "/")
+endif(CMAKE_INSTALL_PREFIX)
+
+execute_process(
+ COMMAND
+ ${PYTHON_EXECUTABLE} -c "from distutils import sysconfig; print sysconfig.get_python_lib(1,0,prefix='${PYTHON_INSTALL_TEMPLATE}')"
+ OUTPUT_VARIABLE PYTHON_INSTDIR
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+include_directories(".")
+
+if(${WITH_TCMALLOC})
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free")
+ set(TCMALLOC_LIBS tcmalloc)
+ set(TCMALLOC_srcs perfglue/heap_profiler.cc)
+else()
+ set(TCMALLOC_srcs perfglue/disabled_heap_profiler.cc)
+endif(${WITH_TCMALLOC})
+
+# tcmalloc heap profiler
+set(heap_profiler_files ${TCMALLOC_srcs})
+add_library(heap_profiler_objs OBJECT ${heap_profiler_files})
+
+set(LIBEDIT_LIBS edit)
+
+# Common infrastructure
+configure_file(
+ ${CMAKE_SOURCE_DIR}/src/ceph_ver.h.in.cmake
+ ${CMAKE_BINARY_DIR}/src/include/ceph_ver.h
+ @ONLY)
+
+set(arch_files
+ arch/arm.c
+ arch/intel.c
+ arch/probe.cc)
+
+set(auth_files
+ auth/AuthAuthorizeHandler.cc
+ auth/AuthClientHandler.cc
+ auth/AuthSessionHandler.cc
+ auth/AuthMethodList.cc
+ auth/cephx/CephxAuthorizeHandler.cc
+ auth/cephx/CephxClientHandler.cc
+ auth/cephx/CephxProtocol.cc
+ auth/cephx/CephxSessionHandler.cc
+ auth/none/AuthNoneAuthorizeHandler.cc
+ auth/unknown/AuthUnknownAuthorizeHandler.cc
+ auth/Crypto.cc
+ auth/KeyRing.cc
+ auth/RotatingKeyRing.cc)
+
+set(mds_files)
+list(APPEND mds_files
+ mds/MDSMap.cc
+ mds/inode_backtrace.cc
+ mds/mdstypes.cc)
+
+set(crush_srcs
+ crush/builder.c
+ crush/mapper.c
+ crush/crush.c
+ crush/hash.c
+ crush/CrushWrapper.cc
+ crush/CrushCompiler.cc
+ crush/CrushTester.cc)
+
+add_subdirectory(json_spirit)
+
+set(libcommon_files
+ ${CMAKE_BINARY_DIR}/src/include/ceph_ver.h
+ ceph_ver.c
+ common/DecayCounter.cc
+ common/LogClient.cc
+ common/LogEntry.cc
+ common/PrebufferedStreambuf.cc
+ common/BackTrace.cc
+ common/perf_counters.cc
+ common/Mutex.cc
+ common/OutputDataSocket.cc
+ common/admin_socket.cc
+ common/admin_socket_client.cc
+ common/bloom_filter.cc
+ common/Readahead.cc
+ ${crush_srcs}
+ common/cmdparse.cc
+ common/escape.c
+ common/io_priority.cc
+ common/Clock.cc
+ common/Throttle.cc
+ common/Timer.cc
+ common/Finisher.cc
+ common/environment.cc
+ common/sctp_crc32.c
+ common/crc32c.cc
+ common/crc32c_intel_baseline.c
+ common/crc32c_intel_fast.c
+ common/assert.cc
+ common/run_cmd.cc
+ common/WorkQueue.cc
+ common/ConfUtils.cc
+ common/MemoryModel.cc
+ common/fd.cc
+ common/xattr.c
+ common/str_list.cc
+ common/str_map.cc
+ common/snap_types.cc
+ common/errno.cc
+ common/TrackedOp.cc
+ common/SloppyCRCMap.cc
+ common/types.cc
+ log/Log.cc
+ log/SubsystemMap.cc
+ mon/MonCap.cc
+ mon/MonClient.cc
+ mon/MonMap.cc
+ msg/simple/Accepter.cc
+ msg/simple/DispatchQueue.cc
+ msg/Message.cc
+ osd/ECMsgTypes.cc
+ osd/HitSet.cc
+ common/RefCountedObj.cc
+ msg/Messenger.cc
+ msg/simple/Pipe.cc
+ msg/simple/PipeConnection.cc
+ msg/simple/SimpleMessenger.cc
+ msg/async/AsyncConnection.cc
+ msg/async/AsyncMessenger.cc
+ msg/async/Event.cc
+ msg/async/EventEpoll.cc
+ msg/async/EventSelect.cc
+ msg/async/net_handler.cc
+ ${xio_common_srcs}
+ msg/msg_types.cc
+ common/hobject.cc
+ osd/OSDMap.cc
+ common/histogram.cc
+ osd/osd_types.cc
+ common/blkdev.cc
+ common/common_init.cc
+ common/pipe.c
+ common/ceph_argparse.cc
+ common/ceph_context.cc
+ common/buffer.cc
+ common/code_environment.cc
+ common/dout.cc
+ common/signal.cc
+ common/simple_spin.cc
+ common/Thread.cc
+ common/Formatter.cc
+ common/HeartbeatMap.cc
+ common/ceph_fs.cc
+ common/ceph_hash.cc
+ common/ceph_strings.cc
+ common/ceph_frag.cc
+ common/config.cc
+ common/utf8.c
+ common/mime.c
+ common/strtol.cc
+ common/page.cc
+ common/lockdep.cc
+ common/version.cc
+ common/hex.cc
+ common/entity_name.cc
+ common/ceph_crypto.cc
+ common/ceph_crypto_cms.cc
+ common/ceph_json.cc
+ common/ipaddr.cc
+ common/pick_address.cc
+ common/linux_version.c
+ osdc/Striper.cc
+ osdc/Objecter.cc
+ ${arch_files}
+ ${auth_files}
+ ${mds_files})
+set(mon_common_files
+ auth/AuthSessionHandler.cc
+ auth/cephx/CephxSessionHandler.cc
+ erasure-code/ErasureCodePlugin.cc)
+add_library(mon_common_objs OBJECT ${mon_common_files})
+set(common_mountcephfs_files
+ common/armor.c
+ common/safe_io.c
+ common/module.c
+ common/addr_parsing.c)
+add_library(common_mountcephfs_objs OBJECT
+ ${common_mountcephfs_files})
+
+if(${WITH_PROFILER})
+ list(APPEND libcommon_files
+ perfglue/cpu_profiler.cc)
+else()
+ list(APPEND libcommon_files
+ perfglue/disabled_stubs.cc)
+endif(${WITH_PROFILER})
+
+if(${ENABLE_SHARED})
+ list(APPEND libcommon_files
+ $<TARGET_OBJECTS:global_common_objs>)
+endif(${ENABLE_SHARED})
+
+add_library(common STATIC ${libcommon_files}
+ $<TARGET_OBJECTS:mon_common_objs>
+ $<TARGET_OBJECTS:common_mountcephfs_objs>)
+
+set_source_files_properties(${CMAKE_SOURCE_DIR}/src/ceph_ver.c
+ ${CMAKE_SOURCE_DIR}/src/common/version.cc
+ ${CMAKE_SOURCE_DIR}/src/test/encoding/ceph_dencoder.cc
+ APPEND PROPERTY OBJECT_DEPENDS ${CMAKE_BINARY_DIR}/src/include/ceph_ver.h)
+
+if(${WITH_PROFILER})
+ target_link_libraries(common profiler)
+endif(${WITH_PROFILER})
+
+target_link_libraries(common json_spirit erasure_code rt uuid ${CRYPTO_LIBS} ${Boost_LIBRARIES})
+
+set(libglobal_srcs
+ global/global_init.cc
+ global/pidfile.cc
+ global/signal_handler.cc)
+set(global_common_files
+ global/global_context.cc)
+add_library(global_common_objs OBJECT ${global_common_files})
+add_library(global STATIC ${libglobal_srcs}
+ $<TARGET_OBJECTS:global_common_objs>)
+target_link_libraries(global common ${CMAKE_THREAD_LIBS_INIT} ${CRYPTO_LIBS}
+ ${EXTRALIBS})
+if(${ENABLE_SHARED})
+ set_target_properties(global PROPERTIES
+ OUTPUT_NAME ceph-global VERSION "1.0.0" SOVERSION "1")
+endif(${ENABLE_SHARED})
+
+# rados object classes
+add_subdirectory(cls)
+
+# RADOS client/library
+set(osdc_files
+ osdc/Objecter.cc)
+set(osdc_rbd_files
+ osdc/ObjectCacher.cc
+ osdc/Striper.cc)
+if(${WITH_CLIENT})
+ list(APPEND osdc_files
+ osdc/Filer.cc)
+endif(${WITH_CLIENT})
+add_library(osdc_rbd_objs OBJECT ${osdc_rbd_files})
+add_library(osdc STATIC ${osdc_files} $<TARGET_OBJECTS:osdc_rbd_objs>)
+
+set(librados_srcs
+ librados/librados.cc
+ librados/RadosClient.cc
+ librados/IoCtxImpl.cc
+ librados/snap_set_diff.cc
+ librados/RadosXattrIter.cc
+ )
+add_library(librados ${CEPH_SHARED} ${librados_srcs}
+ $<TARGET_OBJECTS:cls_references_objs>
+ $<TARGET_OBJECTS:heap_profiler_objs>)
+add_dependencies(librados osdc)
+target_link_libraries(librados PRIVATE osdc osd os global common cls_lock_client
+ ${CRYPTO_LIBS} ${EXTRALIBS} ${TCMALLOC_LIBS})
+if(${ENABLE_SHARED})
+ set_target_properties(librados PROPERTIES OUTPUT_NAME rados VERSION 2.0.0
+ SOVERSION 2)
+endif(${ENABLE_SHARED})
+install(FILES include/rados/librados.h
+ include/rados/rados_types.h
+ include/rados/rados_types.hpp
+ include/rados/librados.hpp
+ include/buffer.h
+ include/page.h
+ include/crc32c.h
+ DESTINATION include/rados)
+install(TARGETS librados DESTINATION lib)
+
+set(rados_srcs
+ tools/rados/rados.cc
+ tools/rados/rados_sync.cc
+ tools/rados/rados_import.cc
+ tools/rados/rados_export.cc
+ common/obj_bencher.cc)
+add_executable(rados ${rados_srcs} $<TARGET_OBJECTS:heap_profiler_objs>)
+target_link_libraries(rados librados global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+set(librados_config_srcs
+ librados-config.cc)
+add_executable(librados-config ${librados_config_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>)
+target_link_libraries(librados-config librados global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS})
+
+install(TARGETS rados librados-config DESTINATION bin)
+
+install(DIRECTORY ${CMAKE_SOURCE_DIR}/src/pybind/
+ DESTINATION ${PYTHON_INSTDIR})
+
+# Monitor
+set(lib_mon_srcs
+ auth/cephx/CephxKeyServer.cc
+ auth/cephx/CephxServiceHandler.cc
+ auth/AuthServiceHandler.cc
+ ${osd_mon_files} mon/Paxos.cc
+ mon/PaxosService.cc
+ mon/OSDMonitor.cc
+ mon/MDSMonitor.cc
+ mon/MonmapMonitor.cc
+ mon/LogMonitor.cc
+ mon/AuthMonitor.cc
+ mon/Elector.cc
+ mon/MonitorStore.cc
+ mon/HealthMonitor.cc
+ ${os_mon_files}
+ mon/DataHealthService.cc
+ mon/PGMonitor.cc
+ mon/PGMap.cc
+ mon/ConfigKeyService.cc)
+
+set(common_util_src
+ common/util.cc)
+set(monitorstore_src
+ mon/MonitorStore.cc)
+add_library(common_util_obj OBJECT ${common_util_src})
+add_library(monitorstore_obj OBJECT ${monitorstore_src})
+add_library(mon STATIC ${lib_mon_srcs} $<TARGET_OBJECTS:mon_common_objs>
+ $<TARGET_OBJECTS:os_mon_objs> $<TARGET_OBJECTS:osd_mon_objs>
+ $<TARGET_OBJECTS:common_util_obj> $<TARGET_OBJECTS:monitorstore_obj>)
+
+set(ceph_mon_srcs
+ ceph_mon.cc
+ common/TextTable.cc)
+add_executable(ceph-mon ${ceph_mon_srcs} $<TARGET_OBJECTS:heap_profiler_objs>)
+target_link_libraries(ceph-mon mon boost_thread common os global ${EXTRALIBS}
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+install(TARGETS ceph-mon DESTINATION bin)
+
+# OSD
+set(libos_srcs
+ os/FileJournal.cc
+ os/FileStore.cc
+ os/chain_xattr.cc
+ os/ObjectStore.cc
+ os/JournalingObjectStore.cc
+ os/LFNIndex.cc
+ os/IndexManager.cc
+ os/FlatIndex.cc
+ os/LevelDBStore.cc
+ os/DBObjectMap.cc
+ os/Transaction.cc
+ os/WBThrottle.cc
+ os/GenericFileStoreBackend.cc
+ os/BtrfsFileStoreBackend.cc
+ os/ZFSFileStoreBackend.cc
+ os/KeyValueStore.cc
+ os/KeyValueDB.cc
+ os/MemStore.cc
+ os/GenericObjectMap.cc
+ os/HashIndex.cc)
+set(os_mon_files
+ os/LevelDBStore.cc)
+add_library(os_mon_objs OBJECT ${os_mon_files})
+add_library(os STATIC ${libos_srcs} $<TARGET_OBJECTS:os_mon_objs>)
+if(${HAVE_LIBAIO})
+ target_link_libraries(os aio)
+endif(${HAVE_LIBAIO})
+target_link_libraries(os leveldb snappy)
+
+set(cls_references_files objclass/class_api.cc)
+add_library(cls_references_objs OBJECT ${cls_references_files})
+
+set(osdc_osd_srcs
+ osdc/Objecter.cc
+ osdc/Striper.cc)
+
+set(osd_srcs
+ osd/OSD.cc
+ osd/Watch.cc
+ osd/ClassHandler.cc
+ osd/OpRequest.cc
+ osd/PG.cc
+ osd/PGLog.cc
+ osd/ReplicatedPG.cc
+ osd/ReplicatedBackend.cc
+ osd/ECBackend.cc
+ osd/ECTransaction.cc
+ osd/PGBackend.cc
+ osd/Ager.cc
+ osd/OSD.cc
+ osd/OSDCap.cc
+ osd/Watch.cc
+ osd/ClassHandler.cc
+ osd/OpRequest.cc
+ common/TrackedOp.cc
+ osd/SnapMapper.cc
+ osd/osd_types.cc
+ osd/ECUtil.cc
+ objclass/class_api.cc
+ ${osdc_osd_srcs})
+set(osd_mon_files
+ mon/Monitor.cc)
+add_library(osd_mon_objs OBJECT ${osd_mon_files})
+add_library(osd STATIC ${osd_srcs} $<TARGET_OBJECTS:osd_mon_objs>
+ $<TARGET_OBJECTS:cls_references_objs>)
+target_link_libraries(osd dl leveldb)
+
+set(ceph_osd_srcs
+ ceph_osd.cc
+ objclass/class_api.cc)
+add_executable(ceph-osd ${ceph_osd_srcs} $<TARGET_OBJECTS:heap_profiler_objs>)
+target_link_libraries(ceph-osd osd os global ${TCMALLOC_LIBS})
+install(TARGETS ceph-osd DESTINATION bin)
+
+# MDS
+if(${WITH_MDS})
+ set(mds_srcs
+ mds/Capability.cc
+ mds/MDS.cc
+ mds/Beacon.cc
+ mds/flock.cc
+ mds/locks.c
+ mds/journal.cc
+ mds/Server.cc
+ mds/Mutation.cc
+ mds/MDCache.cc
+ mds/RecoveryQueue.cc
+ mds/Locker.cc
+ mds/Migrator.cc
+ mds/MDBalancer.cc
+ mds/CDentry.cc
+ mds/CDir.cc
+ mds/CInode.cc
+ mds/LogEvent.cc
+ mds/MDSTable.cc
+ mds/InoTable.cc
+ mds/MDSTableClient.cc
+ mds/MDSTableServer.cc
+ mds/SnapRealm.cc
+ mds/SnapServer.cc
+ mds/snap.cc
+ mds/SessionMap.cc
+ mds/MDSContext.cc
+ mds/MDSAuthCaps.cc
+ mds/MDLog.cc
+ mds/JournalPointer.cc
+ ${CMAKE_SOURCE_DIR}/src/osdc/Journaler.cc)
+ add_library(mds ${mds_srcs})
+ set(ceph_mds_srcs
+ ceph_mds.cc)
+ add_executable(ceph-mds ${ceph_mds_srcs} $<TARGET_OBJECTS:heap_profiler_objs>)
+ target_link_libraries(ceph-mds mds osdc ${CMAKE_DL_LIBS} global
+ ${TCMALLOC_LIBS} boost_thread)
+ install(TARGETS ceph-mds DESTINATION bin)
+endif(${WITH_MDS})
+
+add_subdirectory(erasure-code)
+
+# Support/Tools
+add_subdirectory(gtest)
+add_subdirectory(test)
+set(cephfs_srcs cephfs.cc)
+add_executable(cephfstool ${cephfs_srcs})
+target_link_libraries(cephfstool common ${EXTRALIBS})
+set_target_properties(cephfstool PROPERTIES OUTPUT_NAME cephfs)
+install(TARGETS cephfstool DESTINATION bin)
+
+#set(ceph_srcs tools/ceph.cc tools/common.cc)
+#add_executable(ceph ${ceph_srcs})
+#target_link_libraries(ceph global ${LIBEDIT_LIBS})
+
+set(ceph_conf_srcs
+ tools/ceph_conf.cc)
+add_executable(ceph-conf ${ceph_conf_srcs})
+target_link_libraries(ceph-conf global)
+install(TARGETS ceph-conf DESTINATION bin)
+
+set(monmaptool_srcs
+ tools/monmaptool.cc)
+add_executable(monmaptool ${monmaptool_srcs})
+target_link_libraries(monmaptool global)
+install(TARGETS monmaptool DESTINATION bin)
+
+set(osdomaptool_srcs
+ tools/osdmaptool.cc)
+add_executable(osdmaptool ${osdomaptool_srcs})
+target_link_libraries(osdmaptool global ${CMAKE_DL_LIBS})
+install(TARGETS osdmaptool DESTINATION bin)
+
+set(ceph_authtool_srcs
+ tools/ceph_authtool.cc)
+add_executable(ceph-authtool ${ceph_authtool_srcs})
+target_link_libraries(ceph-authtool global ${EXTRALIBS})
+install(TARGETS ceph-authtool DESTINATION bin)
+
+set(ceph_mon_store_converter_srcs
+ tools/mon_store_converter.cc)
+add_executable(ceph_mon_store_converter ${ceph_mon_store_converter_srcs}
+ $<TARGET_OBJECTS:monitorstore_obj>)
+target_link_libraries(ceph_mon_store_converter os global)
+install(TARGETS ceph_mon_store_converter DESTINATION bin)
+
+configure_file(${CMAKE_SOURCE_DIR}/src/ceph-coverage.in
+ ${CMAKE_BINARY_DIR}/ceph-coverage @ONLY)
+
+configure_file(${CMAKE_SOURCE_DIR}/src/ceph-debugpack.in
+ ${CMAKE_BINARY_DIR}/ceph-debugpack @ONLY)
+
+configure_file(${CMAKE_SOURCE_DIR}/src/ceph.in.cmake
+ ${CMAKE_BINARY_DIR}/ceph @ONLY)
+
+configure_file(${CMAKE_SOURCE_DIR}/src/ceph-crush-location.in
+ ${CMAKE_BINARY_DIR}/ceph-crush-location @ONLY)
+
+configure_file(${CMAKE_SOURCE_DIR}/src/init-ceph.in
+ ${CMAKE_BINARY_DIR}/init-ceph @ONLY)
+
+install(PROGRAMS
+ ${CMAKE_BINARY_DIR}/ceph
+ ${CMAKE_BINARY_DIR}/ceph-debugpack
+ ${CMAKE_BINARY_DIR}/ceph-coverage
+ ${CMAKE_BINARY_DIR}/init-ceph
+ ${CMAKE_SOURCE_DIR}/src/ceph-run
+ ${CMAKE_SOURCE_DIR}/src/vstart.sh
+ ${CMAKE_SOURCE_DIR}/src/ceph-clsinfo
+ DESTINATION bin)
+
+install(FILES
+ ${CMAKE_SOURCE_DIR}/doc/start/ceph.conf
+ DESTINATION ${sysconfdir}/ceph/ RENAME ceph.conf.example)
+
+install(PROGRAMS
+ ${CMAKE_SOURCE_DIR}/src/ceph_common.sh
+ DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/ceph)
+
+install(PROGRAMS
+ ${CMAKE_SOURCE_DIR}/src/ceph-create-keys
+ ${CMAKE_SOURCE_DIR}/src/ceph-disk
+ ${CMAKE_SOURCE_DIR}/src/ceph-disk-activate
+ ${CMAKE_SOURCE_DIR}/src/ceph-disk-prepare
+ ${CMAKE_SOURCE_DIR}/src/ceph-disk-udev
+ DESTINATION sbin)
+
+if(WITH_LIBCEPHFS)
+ set(libclient_srcs
+ client/Client.cc
+ client/Dentry.cc
+ client/Inode.cc
+ client/MetaRequest.cc
+ client/ClientSnapRealm.cc
+ client/MetaSession.cc
+ client/Trace.cc)
+ add_library(client ${libclient_srcs})
+ target_link_libraries(client osdc mds ${LIBEDIT_LIBS})
+ set(libcephfs_srcs libcephfs.cc)
+ add_library(cephfs SHARED ${libcephfs_srcs})
+ target_link_libraries(cephfs client global)
+ install(TARGETS cephfs DESTINATION lib)
+ install(DIRECTORY
+ "${CMAKE_SOURCE_DIR}/src/include/cephfs"
+ DESTINATION include)
+ set(ceph_syn_srcs
+ ceph_syn.cc
+ client/SyntheticClient.cc)
+ add_executable(ceph-syn ${ceph_syn_srcs})
+ target_link_libraries(ceph-syn client global)
+
+ set(mount_ceph_srcs
+ mount/mount.ceph.c)
+ add_executable(mount.ceph ${mount_ceph_srcs}
+ $<TARGET_OBJECTS:common_mountcephfs_objs>
+ $<TARGET_OBJECTS:rbd_mountcephfs_objs>)
+ target_link_libraries(mount.ceph keyutils)
+
+ install(TARGETS ceph-syn DESTINATION bin)
+ install(TARGETS mount.ceph DESTINATION sbin)
+
+ if(WITH_FUSE)
+ set(ceph_fuse_srcs
+ ceph_fuse.cc
+ client/fuse_ll.cc)
+ add_executable(ceph-fuse ${ceph_fuse_srcs})
+ target_link_libraries(ceph-fuse fuse client global)
+ install(TARGETS ceph-fuse DESTINATION bin)
+ endif(WITH_FUSE)
+endif(WITH_LIBCEPHFS)
+
+if(${WITH_RBD})
+ set(librbd_srcs
+ librbd/librbd.cc
+ krbd.cc
+ librbd/AioCompletion.cc
+ librbd/AioRequest.cc
+ librbd/ImageCtx.cc
+ librbd/internal.cc
+ librbd/LibrbdWriteback.cc
+ librbd/WatchCtx.cc)
+ add_library(librbd ${CEPH_SHARED} ${librbd_srcs}
+ $<TARGET_OBJECTS:osdc_rbd_objs>
+ $<TARGET_OBJECTS:common_util_obj>)
+ target_link_libraries(librbd PRIVATE librados common cls_lock_client cls_rbd_client
+ ${CMAKE_DL_LIBS})
+ if(${ENABLE_SHARED})
+ set_target_properties(librbd PROPERTIES VERSION "1.0.0" SOVERSION "1"
+ OUTPUT_NAME rbd)
+ endif(${ENABLE_SHARED})
+ install(TARGETS librados librbd DESTINATION lib)
+ set(rbd_srcs
+ rbd.cc common/TextTable.cc)
+ set(rbd_mountcephfs_files
+ common/secret.c)
+ add_library(rbd_mountcephfs_objs OBJECT ${rbd_mountcephfs_files})
+ add_executable(rbd ${rbd_srcs} $<TARGET_OBJECTS:common_util_obj>
+ $<TARGET_OBJECTS:rbd_mountcephfs_objs>
+ $<TARGET_OBJECTS:heap_profiler_objs>)
+ set_target_properties(rbd PROPERTIES OUTPUT_NAME rbd)
+ target_link_libraries(rbd global librbd librados common keyutils udev
+ ${BLKID_LIBRARIES} ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+ install(TARGETS rbd DESTINATION bin)
+ install(PROGRAMS ${CMAKE_SOURCE_DIR}/src/ceph-rbdnamer DESTINATION bin)
+endif(${WITH_RBD})
+
+# RadosGW
+if(${WITH_KVS})
+ set(kvs_srcs
+ key_value_store/cls_kvs.cc)
+ add_library(cls_kvs SHARED ${kvs_srcs})
+ set_target_properties(cls_kvs PROPERTIES VERSION "1.0.0" SOVERSION "1")
+ install(TARGETS cls_kvs DESTINATION lib/rados-classes)
+endif(${WITH_KVS})
+
+if(${WITH_RADOSGW})
+ set(rgw_a_srcs
+ rgw/librgw.cc
+ rgw/rgw_acl.cc
+ rgw/rgw_acl_s3.cc
+ rgw/rgw_acl_swift.cc
+ rgw/rgw_client_io.cc
+ rgw/rgw_fcgi.cc
+ rgw/rgw_xml.cc
+ rgw/rgw_usage.cc
+ rgw/rgw_json_enc.cc
+ rgw/rgw_user.cc
+ rgw/rgw_bucket.cc
+ rgw/rgw_tools.cc
+ rgw/rgw_rados.cc
+ rgw/rgw_http_client.cc
+ rgw/rgw_rest_client.cc
+ rgw/rgw_rest_conn.cc
+ rgw/rgw_op.cc
+ rgw/rgw_common.cc
+ rgw/rgw_cache.cc
+ rgw/rgw_formats.cc
+ rgw/rgw_log.cc
+ rgw/rgw_multi.cc
+ rgw/rgw_policy_s3.cc
+ rgw/rgw_gc.cc
+ rgw/rgw_multi_del.cc
+ rgw/rgw_env.cc
+ rgw/rgw_cors.cc
+ rgw/rgw_cors_s3.cc
+ rgw/rgw_auth_s3.cc
+ rgw/rgw_metadata.cc
+ rgw/rgw_replica_log.cc
+ rgw/rgw_keystone.cc
+ rgw/rgw_quota.cc
+ rgw/rgw_dencoder.cc)
+
+ add_library(rgw_a STATIC ${rgw_a_srcs})
+
+ include_directories("${CMAKE_SOURCE_DIR}/src/civetweb/include")
+
+ set(radosgw_srcs
+ rgw/rgw_civetweb.cc
+ rgw/rgw_resolve.cc
+ rgw/rgw_rest.cc
+ rgw/rgw_rest_swift.cc
+ rgw/rgw_rest_s3.cc
+ rgw/rgw_rest_usage.cc
+ rgw/rgw_rest_user.cc
+ rgw/rgw_rest_bucket.cc
+ rgw/rgw_http_client.cc
+ rgw/rgw_swift.cc
+ rgw/rgw_swift_auth.cc
+ rgw/rgw_main.cc
+ rgw/rgw_keystone.cc
+ rgw/rgw_loadgen.cc
+ rgw/rgw_rest_client.cc
+ rgw/rgw_metadata.cc
+ rgw/rgw_rest_config.cc
+ rgw/rgw_rest_conn.cc
+ rgw/rgw_rest_log.cc
+ rgw/rgw_rest_metadata.cc
+ rgw/rgw_rest_opstate.cc
+ rgw/rgw_rest_replica_log.cc
+ ${kvs_srcs})
+
+ set(radosgw_srcs
+ rgw/rgw_resolve.cc
+ rgw/rgw_rest.cc
+ rgw/rgw_rest_swift.cc
+ rgw/rgw_rest_s3.cc
+ rgw/rgw_rest_usage.cc
+ rgw/rgw_rest_user.cc
+ rgw/rgw_rest_bucket.cc
+ rgw/rgw_rest_metadata.cc
+ rgw/rgw_replica_log.cc
+ rgw/rgw_rest_log.cc
+ rgw/rgw_rest_opstate.cc
+ rgw/rgw_rest_replica_log.cc
+ rgw/rgw_rest_config.cc
+ rgw/rgw_http_client.cc
+ rgw/rgw_swift.cc
+ rgw/rgw_swift_auth.cc
+ rgw/rgw_loadgen.cc
+ rgw/rgw_civetweb.cc
+ rgw/rgw_civetweb_log.cc
+ civetweb/src/civetweb.c
+ rgw/rgw_main.cc)
+
+ add_executable(radosgw ${radosgw_srcs} $<TARGET_OBJECTS:heap_profiler_objs>)
+ target_link_libraries(radosgw rgw_a librados
+ cls_rgw_client cls_lock_client cls_refcount_client
+ cls_log_client cls_statelog_client cls_version_client
+ cls_replica_log_client cls_user_client
+ curl expat global fcgi resolv ${TCMALLOC_LIBS})
+ install(TARGETS radosgw DESTINATION bin)
+endif(${WITH_RADOSGW})
--- /dev/null
+#!@PYTHON_EXECUTABLE@
+# -*- mode:python -*-
+# vim: ts=4 sw=4 smarttab expandtab
+#
+# Processed in Makefile to add python #! line and version variable
+#
+#
+
+
+"""
+ceph.in becomes ceph, the command-line management tool for Ceph clusters.
+This is a replacement for tools/ceph.cc and tools/common.cc.
+
+Copyright (C) 2013 Inktank Storage, Inc.
+
+This is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public
+License version 2, as published by the Free Software
+Foundation. See file COPYING.
+"""
+
+import os
+import sys
+
+# Make life easier on developers:
+# If in src/, and .libs and pybind exist here, assume we're running
+# from a Ceph source dir and tweak PYTHONPATH and LD_LIBRARY_PATH
+# to use local files
+
+MYPATH = os.path.abspath(__file__)
+MYDIR = os.path.dirname(MYPATH)
+DEVMODEMSG = '*** DEVELOPER MODE: setting PATH, PYTHONPATH and LD_LIBRARY_PATH ***'
+
+if MYDIR.endswith('src') and \
+ os.path.exists(os.path.join(MYDIR, '.libs')) and \
+ os.path.exists(os.path.join(MYDIR, 'pybind')):
+ MYLIBPATH = os.path.join(MYDIR, '.libs')
+ if 'LD_LIBRARY_PATH' in os.environ:
+ if MYLIBPATH not in os.environ['LD_LIBRARY_PATH']:
+ os.environ['LD_LIBRARY_PATH'] += ':' + MYLIBPATH
+ print >> sys.stderr, DEVMODEMSG
+ os.execvp('python', ['python'] + sys.argv)
+ else:
+ os.environ['LD_LIBRARY_PATH'] = MYLIBPATH
+ print >> sys.stderr, DEVMODEMSG
+ os.execvp('python', ['python'] + sys.argv)
+ sys.path.insert(0, os.path.join(MYDIR, 'pybind'))
+ if MYDIR not in os.environ['PATH']:
+ os.environ['PATH'] += ':' + MYDIR
+
+import argparse
+import errno
+import json
+import rados
+import signal
+import socket
+import string
+import struct
+import subprocess
+
+from ceph_argparse import \
+ concise_sig, descsort, parse_json_funcsigs, \
+ matchnum, validate_command, find_cmd_target, \
+ send_command, json_command
+
+# just a couple of globals
+
+verbose = False
+cluster_handle = None
+
+############################################################################
+
+def osdids():
+ ret, outbuf, outs = json_command(cluster_handle, prefix='osd ls')
+ if ret == -errno.EINVAL:
+ # try old mon
+ ret, outbuf, outs = send_command(cluster_handle, cmd=['osd', 'ls'])
+ if ret:
+ raise RuntimeError('Can\'t contact mon for osd list')
+ return [i for i in outbuf.split('\n') if i != '']
+
+def monids():
+ ret, outbuf, outs = json_command(cluster_handle, prefix='mon dump',
+ argdict={'format':'json'})
+ if ret == -errno.EINVAL:
+ # try old mon
+ ret, outbuf, outs = send_command(cluster_handle,
+ cmd=['mon', 'dump', '--format=json'])
+ if ret:
+ raise RuntimeError('Can\'t contact mon for mon list')
+ d = json.loads(outbuf)
+ return [m['name'] for m in d['mons']]
+
+def mdsids():
+ ret, outbuf, outs = json_command(cluster_handle, prefix='mds dump',
+ argdict={'format':'json'})
+ if ret == -errno.EINVAL:
+ # try old mon
+ ret, outbuf, outs = send_command(cluster_handle,
+ cmd=['mds', 'dump', '--format=json'])
+ if ret:
+ raise RuntimeError('Can\'t contact mon for mds list')
+ d = json.loads(outbuf)
+ l = []
+ infodict = d['info']
+ for mdsdict in infodict.values():
+ l.append(mdsdict['name'])
+ return l
+
+def parse_cmdargs(args=None, target=''):
+ # alias: let the line-wrapping be sane
+ AP = argparse.ArgumentParser
+
+ # format our own help
+ parser = AP(description='Ceph administration tool', add_help=False)
+
+ parser.add_argument('--completion', action='store_true',
+ help=argparse.SUPPRESS)
+
+ parser.add_argument('-h', '--help', help='request mon help',
+ action='store_true')
+
+ parser.add_argument('-c', '--conf', dest='cephconf',
+ help='ceph configuration file')
+ parser.add_argument('-i', '--in-file', dest='input_file',
+ help='input file')
+ parser.add_argument('-o', '--out-file', dest='output_file',
+ help='output file')
+
+ parser.add_argument('--id', '--user', dest='client_id',
+ help='client id for authentication')
+ parser.add_argument('--name', '-n', dest='client_name',
+ help='client name for authentication')
+ parser.add_argument('--cluster', help='cluster name')
+
+ parser.add_argument('--admin-daemon', dest='admin_socket',
+ help='submit admin-socket commands (\"help\" for help')
+ parser.add_argument('--admin-socket', dest='admin_socket_nope',
+ help='you probably mean --admin-daemon')
+
+ parser.add_argument('-s', '--status', action='store_true',
+ help='show cluster status')
+
+ parser.add_argument('-w', '--watch', action='store_true',
+ help='watch live cluster changes')
+ parser.add_argument('--watch-debug', action='store_true',
+ help='watch debug events')
+ parser.add_argument('--watch-info', action='store_true',
+ help='watch info events')
+ parser.add_argument('--watch-sec', action='store_true',
+ help='watch security events')
+ parser.add_argument('--watch-warn', action='store_true',
+ help='watch warn events')
+ parser.add_argument('--watch-error', action='store_true',
+ help='watch error events')
+
+ parser.add_argument('--version', '-v', action="store_true", help="display version")
+ parser.add_argument('--verbose', action="store_true", help="make verbose")
+ parser.add_argument('--concise', dest='verbose', action="store_false",
+ help="make less verbose")
+
+ parser.add_argument('-f', '--format', choices=['json', 'json-pretty',
+ 'xml', 'xml-pretty', 'plain'], dest='output_format')
+
+ parser.add_argument('--connect-timeout', dest='cluster_timeout',
+ type=int,
+ help='set a timeout for connecting to the cluster')
+
+ # returns a Namespace with the parsed args, and a list of all extras
+ parsed_args, extras = parser.parse_known_args(args)
+
+ return parser, parsed_args, extras
+
+
+def hdr(s):
+ print '\n', s, '\n', '=' * len(s)
+
+def do_basic_help(parser, args):
+ """
+ Print basic parser help
+ If the cluster is available, get and print monitor help
+ """
+ hdr('General usage:')
+ parser.print_help()
+
+def do_extended_help(parser, args):
+ def help_for_sigs(sigs, partial=None):
+ sys.stdout.write(format_help(parse_json_funcsigs(sigs, 'cli'),
+ partial=partial))
+
+ def help_for_target(target, partial=None):
+ ret, outbuf, outs = json_command(cluster_handle, target=target,
+ prefix='get_command_descriptions',
+ timeout=10)
+ if ret:
+ print >> sys.stderr, \
+ "couldn't get command descriptions for {0}: {1}".\
+ format(target, outs)
+ else:
+ help_for_sigs(outbuf, partial)
+
+ partial = ' '.join(args)
+ if (cluster_handle.state == "connected"):
+ help_for_target(target=('mon', ''), partial=partial)
+ return 0
+
+DONTSPLIT = string.letters + '{[<>]}'
+
+def wrap(s, width, indent):
+ """
+ generator to transform s into a sequence of strings width or shorter,
+ for wrapping text to a specific column width.
+ Attempt to break on anything but DONTSPLIT characters.
+ indent is amount to indent 2nd-through-nth lines.
+
+ so "long string long string long string" width=11 indent=1 becomes
+ 'long string', ' long string', ' long string' so that it can be printed
+ as
+ long string
+ long string
+ long string
+
+ Consumes s.
+ """
+ result = ''
+ leader = ''
+ while len(s):
+
+ if (len(s) <= width):
+ # no splitting; just possibly indent
+ result = leader + s
+ s = ''
+ yield result
+
+ else:
+ splitpos = width
+ while (splitpos > 0) and (s[splitpos-1] in DONTSPLIT):
+ splitpos -= 1
+
+ if splitpos == 0:
+ splitpos = width
+
+ if result:
+ # prior result means we're mid-iteration, indent
+ result = leader
+ else:
+ # first time, set leader and width for next
+ leader = ' ' * indent
+ width -= 1 # for subsequent space additions
+
+ # remove any leading spaces in this chunk of s
+ result += s[:splitpos].lstrip()
+ s = s[splitpos:]
+
+ yield result
+
+ raise StopIteration
+
+def format_help(cmddict, partial=None):
+ """
+ Formats all the cmdsigs and helptexts from cmddict into a sorted-by-
+ cmdsig 2-column display, with each column wrapped and indented to
+ fit into 40 characters.
+ """
+
+ fullusage = ''
+ for cmd in sorted(cmddict.itervalues(), cmp=descsort):
+
+ if not cmd['help']:
+ continue
+ concise = concise_sig(cmd['sig'])
+ if partial and not concise.startswith(partial):
+ continue
+ siglines = [l for l in wrap(concise, 40, 1)]
+ helplines = [l for l in wrap(cmd['help'], 39, 1)]
+
+ # make lists the same length
+ maxlen = max(len(siglines), len(helplines))
+ siglines.extend([''] * (maxlen - len(siglines)))
+ helplines.extend([''] * (maxlen - len(helplines)))
+
+ # so we can zip them for output
+ for (s, h) in zip(siglines, helplines):
+ fullusage += '{0:40s} {1}\n'.format(s, h)
+
+ return fullusage
+
+def admin_socket(asok_path, cmd, format=''):
+ """
+ Send a daemon (--admin-daemon) command 'cmd'. asok_path is the
+ path to the admin socket; cmd is a list of strings; format may be
+ set to one of the formatted forms to get output in that form
+ (daemon commands don't support 'plain' output).
+ """
+
+ def do_sockio(path, cmd):
+ """ helper: do all the actual low-level stream I/O """
+ sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ sock.connect(path)
+ try:
+ sock.sendall(cmd + '\0')
+ len_str = sock.recv(4)
+ if len(len_str) < 4:
+ raise RuntimeError("no data returned from admin socket")
+ l, = struct.unpack(">I", len_str)
+ ret = ''
+
+ got = 0
+ while got < l:
+ bit = sock.recv(l - got)
+ ret += bit
+ got += len(bit)
+
+ except Exception as e:
+ raise RuntimeError('exception: ' + str(e))
+ return ret
+
+ try:
+ cmd_json = do_sockio(asok_path,
+ json.dumps({"prefix":"get_command_descriptions"}))
+ except Exception as e:
+ raise RuntimeError('exception getting command descriptions: ' + str(e))
+
+ if cmd == 'get_command_descriptions':
+ return cmd_json
+
+ sigdict = parse_json_funcsigs(cmd_json, 'cli')
+ valid_dict = validate_command(sigdict, cmd)
+ if not valid_dict:
+ raise RuntimeError('invalid command')
+
+ if format:
+ valid_dict['format'] = format
+
+ try:
+ ret = do_sockio(asok_path, json.dumps(valid_dict))
+ except Exception as e:
+ raise RuntimeError('exception: ' + str(e))
+
+ return ret
+
+
+def ceph_conf(field, name):
+ p = subprocess.Popen(
+ args=[
+ 'ceph-conf',
+ '--show-config-value',
+ field,
+ '-n',
+ name,
+ ],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ outdata, errdata = p.communicate()
+ if (len(errdata)):
+ raise RuntimeError('unable to get conf option %s for %s: %s' % (field, name, errdata))
+ return outdata.rstrip()
+
+def new_style_command(parsed_args, cmdargs, target, sigdict, inbuf, verbose):
+ """
+ Do new-style command dance.
+ target: daemon to receive command: mon (any) or osd.N
+ sigdict - the parsed output from the new monitor describing commands
+ inbuf - any -i input file data
+ verbose - bool
+ """
+ if verbose:
+ for cmdtag in sorted(sigdict.keys()):
+ cmd = sigdict[cmdtag]
+ sig = cmd['sig']
+ print '{0}: {1}'.format(cmdtag, concise_sig(sig))
+
+ got_command = False
+
+ if not got_command:
+ if cmdargs:
+ # Validate input args against list of sigs
+ valid_dict = validate_command(sigdict, cmdargs, verbose)
+ if valid_dict:
+ got_command = True
+ if parsed_args.output_format:
+ valid_dict['format'] = parsed_args.output_format
+ else:
+ return -errno.EINVAL, '', 'invalid command'
+ else:
+ # do the command-interpreter looping
+ # for raw_input to do readline cmd editing
+ import readline
+ while True:
+ interactive_input = raw_input('ceph> ')
+ if interactive_input in ['q', 'quit', 'Q']:
+ return 0, '', ''
+ cmdargs = parse_cmdargs(interactive_input.split())[2]
+ target = find_cmd_target(cmdargs)
+ valid_dict = validate_command(sigdict, cmdargs, verbose)
+ if valid_dict:
+ if parsed_args.output_format:
+ valid_dict['format'] = parsed_args.output_format
+ if verbose:
+ print >> sys.stderr, "Submitting command ", valid_dict
+ ret, outbuf, outs = json_command(cluster_handle,
+ target=target,
+ argdict=valid_dict)
+ if ret:
+ ret = abs(ret)
+ print >> sys.stderr, \
+ 'Error: {0} {1}'.format(ret, errno.errorcode[ret])
+ if outbuf:
+ print outbuf
+ if outs:
+ print >> sys.stderr, 'Status:\n', outs
+ else:
+ print >> sys.stderr, "Invalid command"
+
+ if verbose:
+ print >> sys.stderr, "Submitting command ", valid_dict
+ return json_command(cluster_handle, target=target, argdict=valid_dict,
+ inbuf=inbuf)
+
+def complete(sigdict, args, target):
+ """
+ Command completion. Match as much of [args] as possible,
+ and print every possible match separated by newlines.
+ Return exitcode.
+ """
+ # XXX this looks a lot like the front of validate_command(). Refactor?
+
+ complete_verbose = 'COMPVERBOSE' in os.environ
+
+ # Repulsive hack to handle tell: lop off 'tell' and target
+ # and validate the rest of the command. 'target' is already
+ # determined in our callers, so it's ok to remove it here.
+ if len(args) and args[0] == 'tell':
+ args = args[2:]
+ # look for best match, accumulate possibles in bestcmds
+ # (so we can maybe give a more-useful error message)
+ best_match_cnt = 0
+ bestcmds = []
+ for cmdtag, cmd in sigdict.iteritems():
+ sig = cmd['sig']
+ matched = matchnum(args, sig, partial=True)
+ if (matched > best_match_cnt):
+ if complete_verbose:
+ print >> sys.stderr, \
+ "better match: {0} > {1}: {2}:{3} ".format(matched,
+ best_match_cnt, cmdtag, concise_sig(sig))
+ best_match_cnt = matched
+ bestcmds = [{cmdtag:cmd}]
+ elif matched == best_match_cnt:
+ if complete_verbose:
+ print >> sys.stderr, \
+ "equal match: {0} > {1}: {2}:{3} ".format(matched,
+ best_match_cnt, cmdtag, concise_sig(sig))
+ bestcmds.append({cmdtag:cmd})
+
+ # look through all matching sigs
+ comps = []
+ for cmddict in bestcmds:
+ for cmd in cmddict.itervalues():
+ sig = cmd['sig']
+ # either:
+ # we match everything fully, so we want the next desc, or
+ # we match more partially, so we want the partial match
+ fullindex = matchnum(args, sig, partial=False) - 1
+ partindex = matchnum(args, sig, partial=True) - 1
+ if complete_verbose:
+ print >> sys.stderr, '{}: f {} p {} len {}'.format(sig, fullindex, partindex, len(sig))
+ if fullindex == partindex and fullindex + 1 < len(sig):
+ d = sig[fullindex + 1]
+ else:
+ d = sig[partindex]
+ comps.append(str(d))
+ if complete_verbose:
+ print >> sys.stderr, '\n'.join(comps)
+ print '\n'.join(comps)
+
+ return 0
+
+###
+# ping a monitor
+###
+def ping_monitor(cluster_handle, name):
+ if 'mon.' not in name:
+ print >> sys.stderr, '"ping" expects a monitor to ping; try "ping mon.<id>"'
+ return 1
+
+ mon_id = name[len('mon.'):]
+ s = cluster_handle.ping_monitor(mon_id)
+ print s
+ return 0
+
+###
+# main
+###
+
+def main():
+ ceph_args = os.environ.get('CEPH_ARGS')
+ if ceph_args:
+ sys.argv.extend(ceph_args.split())
+
+ parser, parsed_args, childargs = parse_cmdargs()
+
+ if parsed_args.version:
+ print 'ceph version {0} ({1})'.format(CEPH_GIT_NICE_VER, CEPH_GIT_VER)
+ return 0
+
+ global verbose
+ verbose = parsed_args.verbose
+
+ if parsed_args.admin_socket_nope:
+ print >> sys.stderr, '--admin-socket is used by daemons; '\
+ 'you probably mean --admin-daemon/daemon'
+ return 1
+
+ # pass on --id, --name, --conf
+ name = 'client.admin'
+ if parsed_args.client_id:
+ name = 'client.' + parsed_args.client_id
+ if parsed_args.client_name:
+ name = parsed_args.client_name
+
+ # default '' means default conf search
+ conffile = ''
+ if parsed_args.cephconf:
+ conffile = parsed_args.cephconf
+ # For now, --admin-daemon is handled as usual. Try it
+ # first in case we can't connect() to the cluster
+
+ format = parsed_args.output_format
+
+ sockpath = None
+ if parsed_args.admin_socket:
+ sockpath = parsed_args.admin_socket
+ elif len(childargs) > 0 and childargs[0] == "daemon":
+ # Treat "daemon <path>" or "daemon <name>" like --admin_daemon <path>
+ if len(childargs) > 2:
+ if childargs[1].find('/') >= 0:
+ sockpath = childargs[1]
+ else:
+ # try resolve daemon name
+ try:
+ sockpath = ceph_conf('admin_socket', childargs[1])
+ except Exception as e:
+ print >> sys.stderr, \
+ 'Can\'t get admin socket path: ' + str(e)
+ return errno.EINVAL
+ # for both:
+ childargs = childargs[2:]
+ else:
+ print >> sys.stderr, 'daemon requires at least 3 arguments'
+ return errno.EINVAL
+
+ if sockpath:
+ try:
+ print admin_socket(sockpath, childargs, format)
+ except Exception as e:
+ print >> sys.stderr, 'admin_socket: {0}'.format(e)
+ return errno.EINVAL
+ return 0
+
+ timeout = None
+ if parsed_args.cluster_timeout:
+ timeout = parsed_args.cluster_timeout
+
+ # basic help
+ if parsed_args.help:
+ do_basic_help(parser, childargs)
+
+ # handle any 'generic' ceph arguments that we didn't parse here
+ global cluster_handle
+
+ # rados.Rados() will call rados_create2, and then read the conf file,
+ # and then set the keys from the dict. So we must do these
+ # "pre-file defaults" first (see common_preinit in librados)
+ conf_defaults = {
+ 'log_to_stderr':'true',
+ 'err_to_stderr':'true',
+ 'log_flush_on_exit':'true',
+ }
+
+ clustername = 'ceph'
+ if parsed_args.cluster:
+ clustername = parsed_args.cluster
+
+ try:
+ cluster_handle = rados.Rados(name=name, clustername=clustername,
+ conf_defaults=conf_defaults,
+ conffile=conffile)
+ retargs = cluster_handle.conf_parse_argv(childargs)
+ except rados.Error as e:
+ print >> sys.stderr, 'Error initializing cluster client: {0}'.\
+ format(e.__class__.__name__)
+ return 1
+
+ #tmp = childargs
+ childargs = retargs
+ if not childargs:
+ childargs = []
+
+ # -- means "stop parsing args", but we don't want to see it either
+ if '--' in childargs:
+ childargs.remove('--')
+
+ # special deprecation warning for 'ceph <type> tell'
+ # someday 'mds' will be here too
+ if len(childargs) >= 2 and \
+ childargs[0] in ['mon', 'osd'] and \
+ childargs[1] == 'tell':
+ print >> sys.stderr, '"{0} tell" is deprecated; try "tell {0}.<id>" instead (id can be "*") '.format(childargs[0])
+ return 1
+
+ if parsed_args.help:
+ # short default timeout for -h
+ if not timeout:
+ timeout = 5
+
+ hdr('Monitor commands:')
+ print '[Contacting monitor, timeout after %d seconds]' % timeout
+
+ if childargs and childargs[0] == 'ping':
+ if len(childargs) < 2:
+ print >> sys.stderr, '"ping" requires a monitor name as argument: "ping mon.<id>"'
+ return 1
+
+ try:
+ if childargs and childargs[0] == 'ping':
+ return ping_monitor(cluster_handle, childargs[1])
+ cluster_handle.connect(timeout=timeout)
+ except KeyboardInterrupt:
+ print >> sys.stderr, 'Cluster connection aborted'
+ return 1
+ except Exception as e:
+ print >> sys.stderr, 'Error connecting to cluster: {0}'.\
+ format(e.__class__.__name__)
+ return 1
+
+ if parsed_args.help:
+ return do_extended_help(parser, childargs)
+
+ # implement -w/--watch_*
+ # This is ugly, but Namespace() isn't quite rich enough.
+ level = ''
+ for k, v in parsed_args._get_kwargs():
+ if k.startswith('watch') and v:
+ if k == 'watch':
+ level = 'info'
+ else:
+ level = k.replace('watch_', '')
+ if level:
+
+ # an awfully simple callback
+ def watch_cb(arg, line, who, stamp_sec, stamp_nsec, seq, level, msg):
+ print line
+ sys.stdout.flush()
+
+ # first do a ceph status
+ ret, outbuf, outs = json_command(cluster_handle, prefix='status')
+ if ret == -errno.EINVAL:
+ # try old mon
+ ret, outbuf, outs = send_command(cluster_handle, cmd=['status'])
+ # old mon returns status to outs...ick
+ if ret == 0:
+ outbuf += outs
+ if ret:
+ print >> sys.stderr, "status query failed: ", outs
+ return ret
+ print outbuf
+
+ # this instance keeps the watch connection alive, but is
+ # otherwise unused
+ logwatch = rados.MonitorLog(cluster_handle, level, watch_cb, 0)
+
+ # loop forever letting watch_cb print lines
+ try:
+ signal.pause()
+ except KeyboardInterrupt:
+ # or until ^C, at least
+ return 0
+
+ # read input file, if any
+ inbuf = ''
+ if parsed_args.input_file:
+ try:
+ with open(parsed_args.input_file, 'r') as f:
+ inbuf = f.read()
+ except Exception as e:
+ print >> sys.stderr, 'Can\'t open input file {0}: {1}'.format(parsed_args.input_file, e)
+ return 1
+
+ # prepare output file, if any
+ if parsed_args.output_file:
+ try:
+ outf = open(parsed_args.output_file, 'w')
+ except Exception as e:
+ print >> sys.stderr, \
+ 'Can\'t open output file {0}: {1}'.\
+ format(parsed_args.output_file, e)
+ return 1
+
+ # -s behaves like a command (ceph status).
+ if parsed_args.status:
+ childargs.insert(0, 'status')
+
+ target = find_cmd_target(childargs)
+
+ # Repulsive hack to handle tell: lop off 'tell' and target
+ # and validate the rest of the command. 'target' is already
+ # determined in our callers, so it's ok to remove it here.
+ if len(childargs) and childargs[0] == 'tell':
+ childargs = childargs[2:]
+
+ # fetch JSON sigs from command
+ # each line contains one command signature (a placeholder name
+ # of the form 'cmdNNN' followed by an array of argument descriptors)
+ # as part of the validated argument JSON object
+
+ targets = [target]
+
+ if target[1] == '*':
+ if target[0] == 'osd':
+ targets = [(target[0], o) for o in osdids()]
+ elif target[0] == 'mon':
+ targets = [(target[0], m) for m in monids()]
+
+ final_ret = 0
+ for target in targets:
+ # prettify? prefix output with target, if there was a wildcard used
+ prefix = ''
+ suffix = ''
+ if not parsed_args.output_file and len(targets) > 1:
+ prefix = '{0}.{1}: '.format(*target)
+ suffix = '\n'
+
+ ret, outbuf, outs = json_command(cluster_handle, target=target,
+ prefix='get_command_descriptions')
+ compat = False
+ if ret == -errno.EINVAL:
+ # send command to old monitor or OSD
+ if verbose:
+ print prefix + '{0} to old {1}'.format(' '.join(childargs), target[0])
+ compat = True
+ if parsed_args.output_format:
+ childargs.extend(['--format', parsed_args.output_format])
+ ret, outbuf, outs = send_command(cluster_handle, target, childargs,
+ inbuf)
+
+ if ret == -errno.EINVAL:
+ # did we race with a mon upgrade? try again!
+ ret, outbuf, outs = json_command(cluster_handle, target=target,
+ prefix='get_command_descriptions')
+ if ret == 0:
+ compat = False # yep, carry on
+ if not compat:
+ if ret:
+ if ret < 0:
+ outs = 'problem getting command descriptions from {0}.{1}'.format(*target)
+ else:
+ sigdict = parse_json_funcsigs(outbuf, 'cli')
+
+ if parsed_args.completion:
+ return complete(sigdict, childargs, target)
+
+ ret, outbuf, outs = new_style_command(parsed_args, childargs, target,
+ sigdict, inbuf, verbose)
+
+ # debug tool: send any successful command *again* to
+ # verify that it is idempotent.
+ if not ret and 'CEPH_CLI_TEST_DUP_COMMAND' in os.environ:
+ ret, outbuf, outs = new_style_command(parsed_args, childargs, target,
+ sigdict, inbuf, verbose)
+ if ret < 0:
+ ret = -ret
+ print >> sys.stderr, prefix + 'Second attempt of previously successful command failed with {0}: {1}'.format(errno.errorcode[ret], outs)
+
+ if ret < 0:
+ ret = -ret
+ print >> sys.stderr, prefix + 'Error {0}: {1}'.format(errno.errorcode[ret], outs)
+ if len(targets) > 1:
+ final_ret = ret
+ else:
+ return ret
+
+ # this assumes outs never has useful command output, only status
+ if compat:
+ if ret == 0:
+ # old cli/mon would send status string to stdout on non-error
+ print outs
+ else:
+ if outs:
+ print >> sys.stderr, prefix + outs
+
+ if (parsed_args.output_file):
+ outf.write(outbuf)
+ else:
+ # hack: old code printed status line before many json outputs
+ # (osd dump, etc.) that consumers know to ignore. Add blank line
+ # to satisfy consumers that skip the first line, but not annoy
+ # consumers that don't.
+ if parsed_args.output_format and \
+ parsed_args.output_format.startswith('json') and \
+ not compat:
+ sys.stdout.write('\n')
+
+ # if we are prettifying things, normalize newlines. sigh.
+ if suffix != '':
+ outbuf = outbuf.rstrip()
+ if outbuf != '':
+ sys.stdout.write(prefix + outbuf + suffix)
+
+ sys.stdout.flush()
+
+ if (parsed_args.output_file):
+ outf.close()
+
+ if final_ret:
+ return final_ret
+
+ return 0
+
+if __name__ == '__main__':
+ sys.exit(main())
--- /dev/null
+#ifndef CEPH_VERSION_H
+#define CEPH_VERSION_H
+
+#define CEPH_GIT_VER @CEPH_GIT_VER@
+#define CEPH_GIT_NICE_VER "@CEPH_GIT_NICE_VER@"
+
+#endif
--- /dev/null
+## Rados object classes
+
+# cls_hello
+add_library(cls_hello SHARED hello/cls_hello.cc)
+set_target_properties(cls_hello PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_hello DESTINATION lib/rados-classes)
+
+# cls_rbd
+if (WITH_RBD)
+ add_library(cls_rbd SHARED rbd/cls_rbd.cc)
+ set_target_properties(cls_rbd PROPERTIES VERSION "1.0.0" SOVERSION "1")
+ install(TARGETS cls_rbd DESTINATION lib/rados-classes)
+
+ add_library(cls_rbd_client rbd/cls_rbd_client.cc)
+endif (WITH_RBD)
+
+# cls_lock
+add_library(cls_lock SHARED lock/cls_lock.cc)
+set_target_properties(cls_lock PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_lock DESTINATION lib/rados-classes)
+
+add_library(cls_lock_client
+ lock/cls_lock_client.cc
+ lock/cls_lock_types.cc
+ lock/cls_lock_ops.cc)
+
+# cls_refcount
+add_library(cls_refcount SHARED
+ refcount/cls_refcount.cc
+ refcount/cls_refcount_ops.cc
+ ${CMAKE_SOURCE_DIR}/src/common/ceph_json.cc)
+target_link_libraries(cls_refcount json_spirit)
+set_target_properties(cls_refcount PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_refcount DESTINATION lib/rados-classes)
+
+add_library(cls_refcount_client
+ refcount/cls_refcount_client.cc
+ refcount/cls_refcount_ops.cc)
+
+# cls_version
+add_library(cls_version SHARED version/cls_version.cc)
+set_target_properties(cls_version PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_version DESTINATION lib/rados-classes)
+
+add_library(cls_version_client
+ version/cls_version_client.cc
+ version/cls_version_types.cc)
+
+# cls_log
+add_library(cls_log SHARED log/cls_log.cc)
+set_target_properties(cls_log PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_log DESTINATION lib/rados-classes)
+
+add_library(cls_log_client log/cls_log_client.cc)
+
+# cls_statelog
+add_library(cls_statelog SHARED statelog/cls_statelog.cc)
+set_target_properties(cls_statelog PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_statelog DESTINATION lib/rados-classes)
+
+add_library(cls_statelog_client statelog/cls_statelog_client.cc)
+
+# cls_replica_log
+add_library(cls_replica_log SHARED replica_log/cls_replica_log.cc)
+set_target_properties(cls_replica_log PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_replica_log DESTINATION lib/rados-classes)
+
+add_library(cls_replica_log_client
+ replica_log/cls_replica_log_types.cc
+ replica_log/cls_replica_log_ops.cc
+ replica_log/cls_replica_log_client.cc)
+
+# cls_user
+add_library(cls_user SHARED user/cls_user.cc)
+set_target_properties(cls_user PROPERTIES VERSION "1.0.0" SOVERSION "1")
+install(TARGETS cls_user DESTINATION lib/rados-classes)
+
+add_library(cls_user_client
+ user/cls_user_client.cc
+ user/cls_user_types.cc
+ user/cls_user_ops.cc)
+
+# cls_rgw
+if (WITH_RADOSGW)
+ add_library(cls_rgw SHARED
+ rgw/cls_rgw.cc
+ rgw/cls_rgw_ops.cc
+ rgw/cls_rgw_types.cc
+ ${CMAKE_SOURCE_DIR}/src/common/ceph_json.cc)
+ target_link_libraries(cls_rgw json_spirit)
+ set_target_properties(cls_rgw PROPERTIES VERSION "1.0.0" SOVERSION "1")
+ install(TARGETS cls_rgw DESTINATION lib/rados-classes)
+
+ add_library(cls_rgw_client
+ rgw/cls_rgw_client.cc
+ rgw/cls_rgw_types.cc
+ rgw/cls_rgw_ops.cc)
+endif (WITH_RADOSGW)
--- /dev/null
+## erasure code plugins
+
+set(erasure_codelibdir ${LIBRARY_OUTPUT_PATH}/erasure-code)
+
+add_subdirectory(jerasure)
+add_subdirectory(lrc)
+
+if (WITH_BETTER_YASM_ELF64) # TODO: check for yasm support
+ add_subdirectory(isa)
+endif (WITH_BETTER_YASM_ELF64)
+
+add_library(erasure_code ErasureCodePlugin.cc)
+target_link_libraries(erasure_code dl)
+add_dependencies(erasure_code ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+
+add_library(erasure_code_objs OBJECT ErasureCode.cc)
--- /dev/null
+# ISA
+
+include_directories(isa-l/include)
+
+set(isa_srcs
+ isa-l/erasure_code/ec_base.c
+ isa-l/erasure_code/ec_highlevel_func.c
+ isa-l/erasure_code/ec_multibinary.asm.s
+ isa-l/erasure_code/gf_2vect_dot_prod_avx2.asm.s
+ isa-l/erasure_code/gf_2vect_dot_prod_avx.asm.s
+ isa-l/erasure_code/gf_2vect_dot_prod_sse.asm.s
+ isa-l/erasure_code/gf_3vect_dot_prod_avx2.asm.s
+ isa-l/erasure_code/gf_3vect_dot_prod_avx.asm.s
+ isa-l/erasure_code/gf_3vect_dot_prod_sse.asm.s
+ isa-l/erasure_code/gf_4vect_dot_prod_avx2.asm.s
+ isa-l/erasure_code/gf_4vect_dot_prod_avx.asm.s
+ isa-l/erasure_code/gf_4vect_dot_prod_sse.asm.s
+ isa-l/erasure_code/gf_5vect_dot_prod_avx2.asm.s
+ isa-l/erasure_code/gf_5vect_dot_prod_avx.asm.s
+ isa-l/erasure_code/gf_5vect_dot_prod_sse.asm.s
+ isa-l/erasure_code/gf_6vect_dot_prod_avx2.asm.s
+ isa-l/erasure_code/gf_6vect_dot_prod_avx.asm.s
+ isa-l/erasure_code/gf_6vect_dot_prod_sse.asm.s
+ isa-l/erasure_code/gf_vect_dot_prod_avx2.asm.s
+ isa-l/erasure_code/gf_vect_dot_prod_avx.asm.s
+ isa-l/erasure_code/gf_vect_dot_prod_sse.asm.s
+ isa-l/erasure_code/gf_vect_mul_avx.asm.s
+ isa-l/erasure_code/gf_vect_mul_sse.asm.s
+ ErasureCodeIsa.cc
+ ErasureCodePluginIsa.cc
+ xor_op.cc
+ $<TARGET_OBJECTS:erasure_code_objs>
+)
+
+add_library(ec_isa SHARED ${isa_srcs})
+add_dependencies(ec_isa ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+target_link_libraries(ec_isa ${EXTRALIBS})
+set_target_properties(ec_isa PROPERTIES VERSION 2.10.0 SOVERSION 2)
+install(TARGETS ec_isa DESTINATION lib/erasure-code)
--- /dev/null
+# jerasure plugin
+
+include_directories(gf-complete/include)
+include_directories(jerasure/include)
+
+## detect sse support
+
+# create a tmp file with an empty main()
+set(sse_srcs "${CMAKE_BINARY_DIR}/src/erasure-code/jerasure/tmp_sse.c")
+file(WRITE ${sse_srcs} "void main() {}")
+
+# try each -msse flag
+try_compile(INTEL_SSE ${CMAKE_BINARY_DIR} ${sse_srcs}
+ COMPILE_DEFINITIONS "-msse")
+try_compile(INTEL_SSE2 ${CMAKE_BINARY_DIR} ${sse_srcs}
+ COMPILE_DEFINITIONS "-msse2")
+try_compile(INTEL_SSE3 ${CMAKE_BINARY_DIR} ${sse_srcs}
+ COMPILE_DEFINITIONS "-msse3")
+try_compile(INTEL_SSSE3 ${CMAKE_BINARY_DIR} ${sse_srcs}
+ COMPILE_DEFINITIONS "-mssse3")
+try_compile(INTEL_SSE4_1 ${CMAKE_BINARY_DIR} ${sse_srcs}
+ COMPILE_DEFINITIONS "-msse4.1")
+try_compile(INTEL_SSE4_2 ${CMAKE_BINARY_DIR} ${sse_srcs}
+ COMPILE_DEFINITIONS "-msse4.2")
+
+# clean up tmp file
+file(REMOVE ${sse_srcs})
+
+
+set(jerasure_srcs
+ jerasure/src/cauchy.c
+ jerasure/src/galois.c
+ jerasure/src/jerasure.c
+ jerasure/src/liberation.c
+ jerasure/src/reed_sol.c
+ gf-complete/src/gf_wgen.c
+ gf-complete/src/gf_method.c
+ gf-complete/src/gf_w16.c
+ gf-complete/src/gf.c
+ gf-complete/src/gf_w32.c
+ gf-complete/src/gf_w64.c
+ gf-complete/src/gf_w128.c
+ gf-complete/src/gf_general.c
+ gf-complete/src/gf_w4.c
+ gf-complete/src/gf_rand.c
+ gf-complete/src/gf_w8.c
+ ErasureCodePluginJerasure.cc
+ ErasureCodeJerasure.cc
+ $<TARGET_OBJECTS:erasure_code_objs>
+)
+
+add_library(ec_jerasure_generic SHARED ${jerasure_srcs})
+add_dependencies(ec_jerasure_generic ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+target_link_libraries(ec_jerasure_generic ${EXTRALIBS})
+set_target_properties(ec_jerasure_generic PROPERTIES VERSION 2.0.0 SOVERSION 2)
+install(TARGETS ec_jerasure_generic DESTINATION lib/erasure-code)
+
+# ec_jerasure_sse3
+if(INTEL_SSE)
+ set(JERASURE_SSE3_FLAGS "-msse")
+ if (INTEL_SSE2)
+ set(JERASURE_SSE3_FLAGS "${JERASURE_SSE3_FLAGS} -msse2")
+ endif (INTEL_SSE2)
+ if (INTEL_SSE3)
+ set(JERASURE_SSE3_FLAGS "${JERASURE_SSE3_FLAGS} -msse3")
+ endif (INTEL_SSE3)
+ if (INTEL_SSSE3)
+ set(JERASURE_SSE3_FLAGS "${JERASURE_SSE3_FLAGS} -mssse3")
+ endif (INTEL_SSSE3)
+ add_library(ec_jerasure_sse3 SHARED ${jerasure_srcs})
+ add_dependencies(ec_jerasure_sse3 ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+ target_link_libraries(ec_jerasure_sse3 ${EXTRALIBS})
+ set_target_properties(ec_jerasure_sse3 PROPERTIES VERSION 2.0.0 SOVERSION 2
+ COMPILE_FLAGS ${JERASURE_SSE3_FLAGS})
+ install(TARGETS ec_jerasure_sse3 DESTINATION lib/erasure-code)
+else(INTEL_SSE)
+ message(STATUS "Skipping target ec_jerasure_sse3: -msse not supported")
+endif(INTEL_SSE)
+
+# ec_jerasure_sse4
+if(INTEL_SSE4_1)
+ set(JERASURE_SSE4_FLAGS "${JERASURE_SSE3_FLAGS} -msse4.1")
+ if (INTEL_SSE4_2)
+ set(JERASURE_SSE4_FLAGS "${JERASURE_SSE4_FLAGS} -msse4.2")
+ endif (INTEL_SSE4_2)
+ add_library(ec_jerasure_sse4 SHARED ${jerasure_srcs})
+ add_dependencies(ec_jerasure_sse4 ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+ target_link_libraries(ec_jerasure_sse4 ${EXTRALIBS})
+ set_target_properties(ec_jerasure_sse4 PROPERTIES VERSION 2.0.0 SOVERSION 2
+ COMPILE_FLAGS ${JERASURE_SSE4_FLAGS})
+ install(TARGETS ec_jerasure_sse4 DESTINATION lib/erasure-code)
+else(INTEL_SSE4_1)
+ message(STATUS "Skipping target ec_jerasure_sse4: -msse4.1 not supported")
+endif(INTEL_SSE4_1)
+
+add_library(ec_jerasure SHARED ErasureCodePluginSelectJerasure.cc)
+add_dependencies(ec_jerasure ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+target_link_libraries(ec_jerasure ${EXTRALIBS})
+set_target_properties(ec_jerasure PROPERTIES VERSION 2.0.0 SOVERSION 2)
+install(TARGETS ec_jerasure DESTINATION lib/erasure-code)
--- /dev/null
+# LRC plugin
+
+set(lrc_srcs
+ ErasureCodePluginLrc.cc
+ ErasureCodeLrc.cc
+ $<TARGET_OBJECTS:erasure_code_objs>
+)
+
+add_library(ec_LRC SHARED ${lrc_srcs})
+add_dependencies(ec_LRC ${CMAKE_SOURCE_DIR}/src/ceph_ver.h)
+set_target_properties(ec_LRC PROPERTIES VERSION 1.0.0 SOVERSION 1)
+install(TARGETS ec_LRC DESTINATION lib/erasure-code)
--- /dev/null
+/* config.h file expanded by Cmake for build */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/* fallocate(2) is supported */
+#cmakedefine CEPH_HAVE_FALLOCATE
+
+/* posix_fadvise is supported */
+#cmakedefine HAVE_POSIX_FADVISE
+
+/* posix_fallocate is supported */
+#cmakedefine HAVE_POSIX_FALLOCATE
+
+/* Define if darwin/osx */
+#cmakedefine DARWIN
+
+/* Define if you want C_Gather debugging */
+#cmakedefine DEBUG_GATHER
+
+/* Define if enabling coverage. */
+#cmakedefine ENABLE_COVERAGE
+
+/* FastCGI headers are in /usr/include/fastcgi */
+#cmakedefine FASTCGI_INCLUDE_DIR
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#cmakedefine HAVE_ARPA_INET_H 1
+
+/* have boost::random::discrete_distribution */
+#cmakedefine HAVE_BOOST_RANDOM_DISCRETE_DISTRIBUTION
+
+/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
+ */
+#cmakedefine HAVE_DIRENT_H 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#cmakedefine HAVE_DLFCN_H 1
+
+/* linux/fiemap.h was found, fiemap ioctl will be used */
+#cmakedefine HAVE_FIEMAP_H 1
+
+/* Define to 1 if you have the `fuse_getgroups' function. */
+#cmakedefine HAVE_FUSE_GETGROUPS 1
+
+/* Define to 1 if you have the <linux/types.h> header file. */
+#cmakedefine HAVE_LINUX_TYPES_H 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#cmakedefine HAVE_INTTYPES_H 1
+
+/* Defined if LevelDB supports bloom filters */
+#cmakedefine HAVE_LEVELDB_FILTER_POLICY
+
+/* Defined if you don't have atomic_ops */
+#cmakedefine HAVE_LIBAIO
+
+/* Define to 1 if you have the `boost_system' library (-lboost_system). */
+#cmakedefine HAVE_LIBBOOST_SYSTEM 1
+
+/* Define to 1 if you have the `boost_system-mt' library (-lboost_system-mt).
+ */
+#cmakedefine HAVE_LIBBOOST_SYSTEM_MT 1
+
+/* Define to 1 if you have the `boost_thread' library (-lboost_thread). */
+#cmakedefine HAVE_LIBBOOST_THREAD 1
+
+/* Define to 1 if you have the `boost_thread-mt' library (-lboost_thread-mt).
+ */
+#cmakedefine HAVE_LIBBOOST_THREAD_MT 1
+
+/* Define if you have fuse */
+#cmakedefine HAVE_LIBFUSE
+
+/* Define to 1 if you have the `leveldb' library (-lleveldb). */
+#cmakedefine HAVE_LIBLEVELDB 1
+
+/* Define to 1 if you have the `profiler' library (-lprofiler). */
+#cmakedefine HAVE_LIBPROFILER 1
+
+/* Define to 1 if you have the `snappy' library (-lsnappy). */
+#cmakedefine HAVE_LIBSNAPPY 1
+
+/* Define if you have tcmalloc */
+#cmakedefine HAVE_LIBTCMALLOC
+
+/* Define to 1 if you have the <memory.h> header file. */
+#cmakedefine HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+#cmakedefine HAVE_NDIR_H 1
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#cmakedefine HAVE_NETDB_H 1
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#cmakedefine HAVE_NETINET_IN_H 1
+
+/* Define if you have perftools profiler enabled */
+#cmakedefine HAVE_PROFILER
+
+/* Define if you have POSIX threads libraries and header files. */
+#cmakedefine HAVE_PTHREAD
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#cmakedefine HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#cmakedefine HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#cmakedefine HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#cmakedefine HAVE_STRING_H 1
+
+/* Define to 1 if you have the `syncfs' function. */
+#cmakedefine HAVE_SYNCFS 1
+
+/* sync_file_range(2) is supported */
+#cmakedefine HAVE_SYNC_FILE_RANGE
+
+/* Define to 1 if you have the <syslog.h> header file. */
+#cmakedefine HAVE_SYSLOG_H 1
+
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+ */
+#cmakedefine HAVE_SYS_DIR_H 1
+
+/* Define to 1 if you have the <sys/file.h> header file. */
+#cmakedefine HAVE_SYS_FILE_H 1
+
+/* Define to 1 if you have the <sys/ioctl.h> header file. */
+#cmakedefine HAVE_SYS_IOCTL_H 1
+
+/* Define to 1 if you have the <sys/mount.h> header file. */
+#cmakedefine HAVE_SYS_MOUNT_H 1
+
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+ */
+#cmakedefine HAVE_SYS_NDIR_H 1
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#cmakedefine HAVE_SYS_PARAM_H 1
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#cmakedefine HAVE_SYS_SOCKET_H 1
+
+/* Define to 1 if you have the <sys/statvfs.h> header file. */
+#cmakedefine HAVE_SYS_STATVFS_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#cmakedefine HAVE_SYS_STAT_H 1
+
+/* we have syncfs */
+#cmakedefine HAVE_SYS_SYNCFS
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#cmakedefine HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#cmakedefine HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <sys/vfs.h> header file. */
+#cmakedefine HAVE_SYS_VFS_H 1
+
+/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
+#cmakedefine HAVE_SYS_WAIT_H
+
+/* Define to 1 if you have the <sys/xattr.h> header file. */
+#cmakedefine HAVE_SYS_XATTR_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#cmakedefine HAVE_UNISTD_H
+
+/* Define to 1 if you have the <utime.h> header file. */
+#cmakedefine HAVE_UTIME_H
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+ */
+#cmakedefine LT_OBJDIR
+
+/* Defined if you do not have atomic_ops */
+#cmakedefine NO_ATOMIC_OPS
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+#cmakedefine NO_MINUS_C_MINUS_O
+
+/* Name of package */
+#cmakedefine PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#cmakedefine PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#cmakedefine PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#cmakedefine PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#cmakedefine PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#cmakedefine PACKAGE_URL
+
+/* Define to the version of this package. */
+#cmakedefine PACKAGE_VERSION
+
+/* Defined if you want pg ref debugging */
+#cmakedefine PG_DEBUG_REFS
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+ your system. */
+#cmakedefine PTHREAD_CREATE_JOINABLE
+
+/* Define to 1 if you have the ANSI C header files. */
+#cmakedefine STDC_HEADERS
+
+/* Define if using CryptoPP. */
+#cmakedefine USE_CRYPTOPP
+
+/* Define if using NSS. */
+#cmakedefine USE_NSS
+
+/* Version number of package */
+#cmakedefine VERSION "@VERSION@"
+
+/* define if radosgw enabled */
+#cmakedefine WITH_RADOSGW
+
+/* Defined if XIO */
+#cmakedefine WITH_XIO
+
+/* Defined if CDS */
+#cmakedefine HAVE_CDS
+
+#endif /* CONFIG_H */
#elif defined(__FreeBSD__)
#include <sys/types.h>
#endif
+#include <unistd.h>
#include <string.h>
#include "rados_types.h"
--- /dev/null
+add_library(json_spirit
+ json_spirit_reader.cpp
+ json_spirit_writer.cpp)
--- /dev/null
+# test_timers
+add_executable(test_timers
+ TestTimers.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_timers global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_signal_handlers
+add_executable(test_signal_handlers
+ TestSignalHandlers.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_signal_handlers global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS})
+
+# test_msgr
+add_executable(test_msgr
+ testmsgr.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_msgr global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_crypt
+add_executable(test_crypt
+ testcrypto.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_crypt
+ global
+ ${CRYPTO_LIBS}
+ m
+ ${EXTRALIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ )
+
+# test_rados
+add_executable(test_rados
+ osd/TestRados.cc
+ osd/TestOpStat.cc
+ osd/Object.cc osd/RadosModel.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_rados
+ librados
+ global
+ ${CMAKE_DL_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ )
+
+# test_mutate
+add_executable(test_mutate
+ test_mutate.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_mutate global librados ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS})
+
+# test_rewrite_latency
+add_executable(test_rewrite_latency
+ test_rewrite_latency.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_rewrite_latency common ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_THREAD_LIBS_INIT} ${CRYPTO_LIBS} m ${EXTRALIBS})
+
+# streamtest
+add_executable(streamtest
+ streamtest.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(streamtest os global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_trans
+add_executable(test_trans
+ test_trans.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_trans os global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_keys
+add_executable(test_keys
+ testkeys.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_keys mon global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+## dencoder
+set(dencoder_srcs
+ encoding/ceph_dencoder.cc
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ )
+if(${WITH_RADOSGW})
+ list(APPEND dencoder_srcs
+ ${CMAKE_SOURCE_DIR}/src/rgw/rgw_dencoder.cc
+ ${CMAKE_SOURCE_DIR}/src/rgw/rgw_acl.cc
+ ${CMAKE_SOURCE_DIR}/src/rgw/rgw_common.cc
+ ${CMAKE_SOURCE_DIR}/src/rgw/rgw_env.cc
+ ${CMAKE_SOURCE_DIR}/src/rgw/rgw_json_enc.cc
+ )
+endif(${WITH_RADOSGW})
+add_executable(dencoder ${dencoder_srcs} $<TARGET_OBJECTS:heap_profiler_objs>)
+target_link_libraries(dencoder
+ librados
+ global
+ osd
+ mds
+ mon
+ osdc
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+if(${WITH_RADOSGW})
+ target_link_libraries(dencoder
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ rgw_a
+ cls_rgw_client
+ cls_lock_client
+ cls_refcount_client
+ cls_log_client
+ cls_statelog_client
+ cls_version_client
+ cls_replica_log_client
+ cls_kvs
+ cls_user_client
+ curl
+ expat
+ fcgi
+ resolv
+ )
+endif(${WITH_RADOSGW})
+
+# get_command_descriptions
+add_executable(get_command_descriptions
+ common/get_command_descriptions.cc
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ $<TARGET_OBJECTS:os_mon_objs>
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(get_command_descriptions
+ mon
+ global
+ leveldb
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+## Benchmarks
+
+# smalliobench
+set(smalliobench_srcs
+ bench/small_io_bench.cc
+ bench/rados_backend.cc
+ bench/detailed_stat_collector.cc
+ bench/bencher.cc
+ )
+add_executable(smalliobench
+ ${smalliobench_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(smalliobench librados boost_program_options global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# smalliobenchfs
+set(smalliobenchfs_srcs
+ bench/small_io_bench_fs.cc
+ bench/testfilestore_backend.cc
+ bench/detailed_stat_collector.cc
+ bench/bencher.cc
+ )
+add_executable(smalliobenchfs
+ ${smalliobenchfs_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(smalliobenchfs librados boost_program_options os global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# smalliobenchdumb
+set(smalliobenchdumb_srcs
+ bench/small_io_bench_dumb.cc
+ bench/dumb_backend.cc
+ bench/detailed_stat_collector.cc
+ bench/bencher.cc
+ )
+add_executable(smalliobenchdumb
+ ${smalliobenchdumb_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(smalliobenchdumb librados boost_program_options os global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# smalliobenchrbd
+set(smalliobenchrbd_srcs
+ bench/small_io_bench_rbd.cc
+ bench/rbd_backend.cc
+ bench/detailed_stat_collector.cc
+ bench/bencher.cc
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ ${CMAKE_SOURCE_DIR}/src/common/secret.c
+)
+add_executable(smalliobenchrbd
+ ${smalliobenchrbd_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(smalliobenchrbd
+ librbd
+ librados
+ os
+ global
+ boost_program_options
+ blkid
+ udev
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ keyutils
+ )
+
+# tpbench
+set(tpbench_srcs
+ bench/tp_bench.cc
+ bench/detailed_stat_collector.cc)
+add_executable(tpbench
+ ${tpbench_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(tpbench librados boost_program_options os global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# omapbench
+set(omapbench_srcs
+ omap_bench.cc
+ )
+add_executable(omapbench
+ ${omapbench_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(omapbench
+ librados
+ boost_program_options
+ os
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ )
+
+# kvstorebench
+set(kvstorebench_srcs
+ kv_store_bench.cc
+ ${CMAKE_SOURCE_DIR}/src/key_value_store/kv_flat_btree_async.cc
+ )
+add_executable(kvstorebench
+ ${kvstorebench_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(kvstorebench librados global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS})
+
+## System tests
+
+# systest
+set(libsystest_srcs system/cross_process_sem.cc
+ system/systest_runnable.cc
+ system/systest_settings.cc
+ system/st_rados_create_pool.cc
+ system/st_rados_delete_pool.cc
+ system/st_rados_list_objects.cc
+ system/st_rados_watch.cc
+ system/st_rados_notify.cc)
+add_library(systest STATIC ${libsystest_srcs})
+
+# test_rados_list_parallel
+add_executable(test_rados_list_parallel
+ system/rados_list_parallel.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_rados_list_parallel librados systest global pthread
+ rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_rados_open_pools_parallel
+set(test_rados_open_pools_parallel_srcs system/rados_open_pools_parallel.cc)
+add_executable(test_rados_open_pools_parallel
+ ${test_rados_open_pools_parallel_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_rados_open_pools_parallel librados systest global
+ pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_rados_delete_pools_parallel
+set(test_rados_delete_pools_parallel_srcs
+ system/rados_delete_pools_parallel.cc
+ system/st_rados_create_pool.cc
+ system/st_rados_delete_pool.cc
+ system/st_rados_list_objects.cc
+
+ )
+add_executable(test_rados_delete_pools_parallel
+ ${test_rados_delete_pools_parallel_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_rados_delete_pools_parallel librados systest global
+ pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# test_rados_watch_notify
+set(test_rados_watch_notify_srcs
+ system/rados_watch_notify.cc
+ system/st_rados_create_pool.cc
+ system/st_rados_delete_pool.cc
+ system/st_rados_delete_objs.cc
+ system/st_rados_watch.cc
+ system/st_rados_notify.cc
+ )
+add_executable(test_rados_watch_notify
+ ${test_rados_watch_notify_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_rados_watch_notify librados systest global
+ pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+# bench_log
+set(bench_log_srcs
+ bench_log.cc
+ )
+add_executable(bench_log
+ ${bench_log_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(bench_log global pthread rt ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+## Unit tests
+
+set(UNITTEST_LIBS gtest_main ${PTHREAD_LIBS})
+set(UNITTEST_CXX_FLAGS "-I${CMAKE_SOURCE_DIR}/src/gtest/include -I${CMAKE_BINARY_DIR}/src/gtest/include -fno-strict-aliasing")
+
+# unittest_encoding
+set(unittest_encoding_srcs
+ encoding.cc
+ )
+add_executable(unittest_encoding
+ ${unittest_encoding_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_encoding cephfs librados pthread rt m
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_encoding
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_addrs
+set(unittest_addrs_srcs
+ test_addrs.cc
+ )
+add_executable(unittest_addrs
+ ${unittest_addrs_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_addrs cephfs librados pthread rt m
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_addrs
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_bloom_filter
+set(unittest_bloom_filter_srcs
+ common/test_bloom_filter.cc
+ )
+add_executable(unittest_bloom_filter
+ ${unittest_bloom_filter_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_bloom_filter global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_bloom_filter
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_histogram
+add_executable(unittest_histogram
+ common/histogram.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_histogram global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_histogram
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_str_map
+set(unittest_str_map_srcs
+ common/test_str_map.cc
+ )
+add_executable(unittest_str_map
+ ${unittest_str_map_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_str_map global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_str_map
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_sharedptr_registry
+set(unittest_sharedptr_registry_srcs
+ common/test_sharedptr_registry.cc
+ )
+add_executable(unittest_sharedptr_registry
+ ${unittest_sharedptr_registry_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_sharedptr_registry global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_sharedptr_registry
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_sloppy_crc_map
+set(unittest_sloppy_crc_map_srcs
+ common/test_sloppy_crc_map.cc
+ )
+add_executable(unittest_sloppy_crc_map
+ ${unittest_sloppy_crc_map_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_sloppy_crc_map global
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_sloppy_crc_map
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_util
+set(unittest_util_srcs
+ common/test_util.cc
+ ${CMAKE_SOURCE_DIR}/src/common/util.cc
+ )
+add_executable(unittest_util
+ ${unittest_util_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_util
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ )
+set_target_properties(unittest_util
+ PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_osdmap
+set(unittest_osdmap_srcs osd/TestOSDMap.cc)
+add_executable(unittest_osdmap
+ ${unittest_osdmap_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_osdmap global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_osdmap PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_workqueue
+set(unittest_workqueue_srcs test_workqueue.cc)
+add_executable(unittest_workqueue
+ ${unittest_workqueue_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_workqueue global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_workqueue PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_striper
+set(unittest_striper_srcs test_striper.cc)
+add_executable(unittest_striper
+ ${unittest_striper_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_striper global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_striper PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_prebufferedstreambuf
+set(unittest_prebufferedstreambuf_srcs test_prebufferedstreambuf.cc)
+add_executable(unittest_prebufferedstreambuf
+ ${unittest_prebufferedstreambuf_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_prebufferedstreambuf global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_prebufferedstreambuf PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_str_list
+set(unittest_str_list_srcs test_str_list.cc)
+add_executable(unittest_str_list
+ ${unittest_str_list_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_str_list global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_str_list PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_log
+set(unittest_log_srcs ${CMAKE_SOURCE_DIR}/src/log/test.cc)
+add_executable(unittest_log
+ ${unittest_log_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_log global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_log PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_throttle
+set(unittest_throttle_srcs common/Throttle.cc)
+add_executable(unittest_throttle
+ ${unittest_throttle_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_throttle global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_throttle PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_base64
+set(unittest_base64_srcs base64.cc)
+add_executable(unittest_base64
+ ${unittest_base64_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_base64 global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_base64 PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# unittest_ceph_argparse
+set(unittest_ceph_argparse_srcs ceph_argparse.cc)
+add_executable(unittest_ceph_argparse
+ ${unittest_ceph_argparse_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_ceph_argparse global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_ceph_argparse PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_ceph_compatset
+set(unittest_ceph_compatset_srcs ceph_compatset.cc)
+add_executable(unittest_ceph_compatset
+ ${unittest_ceph_compatset_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_ceph_compatset global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_ceph_compatset PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_osd_types
+set(unittest_osd_types_srcs osd/types.cc)
+add_executable(unittest_osd_types
+ ${unittest_osd_types_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_osd_types global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_osd_types PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_gather
+set(unittest_gather_srcs gather.cc)
+add_executable(unittest_gather
+ ${unittest_gather_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_gather global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_gather PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# run_cmd
+set(unittest_run_cmd_srcs run_cmd.cc)
+add_executable(unittest_run_cmd
+ ${unittest_run_cmd_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_run_cmd global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_run_cmd PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# signals
+set(unittest_signals_srcs signals.cc)
+add_executable(unittest_signals
+ ${unittest_signals_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_signals global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_signals PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_simple_spin
+set(unittest_simple_spin_srcs simple_spin.cc)
+add_executable(unittest_simple_spin
+ ${unittest_simple_spin_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_simple_spin global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_simple_spin PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_librados
+set(unittest_librados_srcs librados/librados.cc)
+add_executable(unittest_librados
+ ${unittest_librados_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_librados
+ librados
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ )
+set_target_properties(unittest_librados PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_bufferlist
+set(unittest_bufferlist_srcs bufferlist.cc)
+add_executable(unittest_bufferlist
+ ${unittest_bufferlist_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_bufferlist global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_bufferlist PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_crc32
+set(unittest_crc32_srcs common/test_crc32c.cc)
+add_executable(unittest_crc32
+ ${unittest_crc32_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_crc32 global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_crc32 PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_arch
+set(unittest_arch_srcs test_arch.cc)
+add_executable(unittest_arch
+ ${unittest_arch_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_arch global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_arch PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_crypto_init
+set(unittest_crypto_init_srcs crypto_init.cc)
+add_executable(unittest_crypto_init
+ ${unittest_crypto_init_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_crypto_init global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_crypto_init PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_perf_counters
+set(unittest_perf_counters_srcs perf_counters.cc)
+add_executable(unittest_perf_counters
+ ${unittest_perf_counters_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_perf_counters global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_perf_counters PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_admin_socket
+set(unittest_admin_socket_srcs admin_socket.cc)
+add_executable(unittest_admin_socket
+ ${unittest_admin_socket_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_admin_socket global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_admin_socket PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_ceph_crypto
+set(unittest_ceph_crypto_srcs ceph_crypto.cc)
+add_executable(unittest_ceph_crypto
+ ${unittest_ceph_crypto_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_ceph_crypto global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_ceph_crypto PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_utf8
+set(unittest_utf8_srcs utf8.cc)
+add_executable(unittest_utf8
+ ${unittest_utf8_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_utf8 global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_utf8 PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_mime
+set(unittest_mime_srcs mime.cc)
+add_executable(unittest_mime
+ ${unittest_mime_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_mime global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_mime PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_escape
+set(unittest_escape_srcs escape.cc)
+add_executable(unittest_escape
+ ${unittest_escape_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_escape global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_escape PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_chain_xattr
+set(unittest_chain_xattr_srcs
+ objectstore/chain_xattr.cc
+ )
+add_executable(unittest_chain_xattr
+ ${unittest_chain_xattr_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(unittest_chain_xattr PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(unittest_chain_xattr
+ os
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ )
+
+# unittest_flatindex
+set(unittest_flatindex_srcs
+ os/TestFlatIndex.cc
+ )
+add_executable(unittest_flatindex
+ ${unittest_flatindex_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_flatindex
+ os
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ )
+set_target_properties(unittest_flatindex PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_strtol
+set(unittest_strtol_srcs strtol.cc)
+add_executable(unittest_strtol
+ ${unittest_strtol_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_strtol global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_strtol PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_confutils
+set(unittest_confutils_srcs confutils.cc)
+add_executable(unittest_confutils
+ ${unittest_confutils_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_confutils global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_confutils PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_config
+set(unittest_config_srcs common/test_config.cc)
+add_executable(unittest_config
+ ${unittest_config_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_config global ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_config PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_context
+set(unittest_context_srcs common/test_context.cc)
+add_executable(unittest_context
+ ${unittest_context_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_context global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_context PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_heartbeatmap
+set(unittest_heartbeatmap_srcs heartbeat_map.cc)
+add_executable(unittest_heartbeatmap
+ ${unittest_heartbeatmap_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_heartbeatmap global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_heartbeatmap PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+if(${WITH_RADOSGW})
+ # unittest_formatter
+ set(unittest_formatter_srcs formatter.cc
+ ${CMAKE_SOURCE_DIR}/src/rgw/rgw_formats.cc)
+ add_executable(unittest_formatter
+ ${unittest_formatter_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(unittest_formatter global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+ set_target_properties(unittest_formatter PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+endif(${WITH_RADOSGW})
+
+# unittest_libcephfs_config
+set(unittest_libcephfs_config_srcs libcephfs_config.cc)
+add_executable(unittest_libcephfs_config
+ ${unittest_libcephfs_config_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_libcephfs_config cephfs ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_libcephfs_config PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_lfnindex
+set(unittest_lfnindex_srcs os/TestLFNIndex.cc)
+add_executable(unittest_lfnindex
+ ${unittest_lfnindex_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_lfnindex os global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_lfnindex PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_librados_config
+set(unittest_librados_config_srcs librados/librados_config.cc)
+add_executable(unittest_librados_config
+ ${unittest_librados_config_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_librados_config
+ librados
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ )
+set_target_properties(unittest_librados_config PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_daemon_config
+set(unittest_daemon_config_srcs daemon_config.cc)
+add_executable(unittest_daemon_config
+ ${unittest_daemon_config_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_daemon_config
+ common
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${EXTRALIBS}
+ )
+set_target_properties(unittest_daemon_config PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_mon_moncap
+set(unittest_mon_moncap_srcs mon/moncap.cc)
+add_executable(unittest_mon_moncap
+ ${unittest_mon_moncap_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_mon_moncap mon global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_mon_moncap PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_ipaddr
+add_executable(unittest_ipaddr test_ipaddr.cc)
+target_link_libraries(unittest_ipaddr mon global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_ipaddr PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_texttable
+set(unittest_texttable_srcs
+ test_texttable.cc
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ )
+add_executable(unittest_texttable
+ ${unittest_texttable_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_texttable mon global ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+set_target_properties(unittest_texttable PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+# unittest_on_exit
+set(unittest_on_exit_srcs on_exit.cc)
+add_executable(unittest_on_exit
+ ${unittest_on_exit_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(unittest_on_exit
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS})
+set_target_properties(unittest_on_exit PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+if(${WITH_RADOSGW})
+ # test_cors
+ set(test_cors_srcs test_cors.cc)
+ add_executable(test_cors
+ ${test_cors_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(test_cors
+ librados
+ rgw_a
+ global
+ curl
+ uuid
+ expat
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS})
+ set_target_properties(test_cors PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+ # test_rgw_manifest
+ set(test_rgw_manifest_srcs rgw/test_rgw_manifest.cc)
+ add_executable(test_rgw_manifest
+ ${test_rgw_manifest_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(test_rgw_manifest
+ rgw_a
+ cls_rgw_client
+ cls_lock_client
+ cls_refcount_client
+ cls_log_client
+ cls_statelog_client
+ cls_version_client
+ cls_replica_log_client
+ cls_kvs
+ cls_user_client
+ librados
+ global
+ curl
+ uuid
+ expat
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ ${CRYPTO_LIBS}
+ )
+ set_target_properties(test_rgw_manifest PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+ # test_cls_rgw_meta
+ set(test_cls_rgw_meta_srcs test_rgw_admin_meta.cc)
+ add_executable(test_cls_rgw_meta
+ ${test_cls_rgw_meta_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(test_cls_rgw_meta
+ librados
+ rgw_a
+ global
+ curl
+ uuid
+ expat
+ cls_version_client
+ cls_log_client
+ cls_statelog_client
+ cls_refcount_client
+ cls_rgw_client
+ cls_user_client
+ cls_lock_client
+ boost_regex
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS} ${UNITTEST_LIBS} ${CRYPTO_LIBS})
+ set_target_properties(test_cls_rgw_meta PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+ # test_cls_rgw_log
+ set(test_cls_rgw_log_srcs
+ test_rgw_admin_log.cc
+ )
+ add_executable(test_cls_rgw_log
+ ${test_cls_rgw_log_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(test_cls_rgw_log
+ librados
+ rgw_a
+ global
+ curl
+ uuid
+ expat
+ cls_version_client
+ cls_log_client
+ cls_statelog_client
+ cls_refcount_client
+ cls_rgw_client
+ cls_user_client
+ cls_lock_client
+ boost_regex
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${CRYPTO_LIBS}
+ )
+ set_target_properties(test_cls_rgw_log PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+
+ # test_cls_rgw_opstate
+ set(test_cls_rgw_opstate_srcs test_rgw_admin_opstate.cc)
+ add_executable(test_cls_rgw_opstate
+ ${test_cls_rgw_opstate_srcs}
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(test_cls_rgw_opstate
+ rgw_a
+ librados
+ cls_version_client
+ cls_log_client
+ cls_statelog_client
+ cls_refcount_client
+ cls_rgw_client
+ cls_user_client
+ cls_lock_client
+ global
+ curl
+ uuid
+ expat
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${UNITTEST_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ )
+ set_target_properties(test_cls_rgw_opstate PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+endif(${WITH_RADOSGW})
+
+# radostest
+set(libradostest_srcs librados/test.cc librados/TestCase.cc)
+add_library(radostest STATIC ${libradostest_srcs})
+set_target_properties(radostest PROPERTIES COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+
+# multi_stress_watch
+add_executable(multi_stress_watch
+ multi_stress_watch.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(multi_stress_watch librados global radostest
+ ${CMAKE_DL_LIBS} ${TCMALLOC_LIBS})
+
+add_executable(test_librbd
+ librbd/test_librbd.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ ${CMAKE_SOURCE_DIR}/src/common/secret.c
+ )
+set_target_properties(test_librbd PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_librbd
+ librbd
+ librados
+ ${UNITTEST_LIBS}
+ global
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ blkid
+ udev
+ keyutils
+ radostest
+ )
+
+add_executable(test_librbd_fsx
+ librbd/fsx.c
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ ${CMAKE_SOURCE_DIR}/src/common/secret.c
+ )
+target_link_libraries(test_librbd_fsx
+ librbd
+ librados
+ global
+ m
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ blkid
+ udev
+ keyutils
+ )
+
+add_executable(test_cls_rbd
+ cls_rbd/test_cls_rbd.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ ${CMAKE_SOURCE_DIR}/src/common/TextTable.cc
+ ${CMAKE_SOURCE_DIR}/src/common/secret.c
+ )
+set_target_properties(test_cls_rbd PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_rbd
+ librbd
+ cls_rbd
+ cls_lock
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ radostest
+ blkid
+ udev
+ keyutils
+ )
+
+add_executable(test_cls_refcount
+ cls_refcount/test_cls_refcount.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_refcount PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_refcount
+ librados
+ cls_refcount_client
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ radostest
+ )
+
+add_executable(test_cls_version
+ cls_version/test_cls_version.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_version PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_version
+ librados
+ cls_version_client
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ radostest
+ )
+
+add_executable(test_cls_log
+ cls_log/test_cls_log.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_log PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_log
+ librados
+ cls_log_client
+ global
+ radostest
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ )
+
+add_executable(test_cls_statelog
+ cls_statelog/test_cls_statelog.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_statelog PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_statelog
+ librados
+ cls_statelog_client
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ radostest
+ )
+
+add_executable(test_cls_replica_log
+ cls_replica_log/test_cls_replica_log.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_replica_log PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_replica_log
+ librados
+ cls_replica_log_client
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ radostest
+ )
+
+add_executable(test_cls_lock
+ cls_lock/test_cls_lock.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_lock PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_lock
+ cls_lock
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${TCMALLOC_LIBS}
+ ${CRYPTO_LIBS}
+ ${EXTRALIBS}
+ radostest
+ )
+
+add_executable(test_cls_hello
+ cls_hello/test_cls_hello.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_cls_hello PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_cls_hello
+ librados
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ ${UNITTEST_LIBS}
+ )
+
+if(${WITH_RADOSGW})
+ add_executable(test_cls_rgw
+ cls_rgw/test_cls_rgw.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ set_target_properties(test_cls_rgw PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+ target_link_libraries(test_cls_rgw
+ cls_rgw_client
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest)
+endif(${WITH_RADOSGW})
+
+add_executable(test_mon_workloadgen
+ mon/test_mon_workloadgen.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_mon_workloadgen
+ os
+ osdc
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_rados_api_cmd
+ librados/cmd.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_cmd PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_cmd
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest)
+
+add_executable(test_rados_api_io
+ librados/io.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_io PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_io
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_c_write_operations
+ librados/c_write_operations.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_c_write_operations PROPERTIES
+ COMPILE_FLAGS ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_c_write_operations
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest)
+
+add_executable(test_rados_api_c_read_operations
+ librados/c_read_operations.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_c_read_operations PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_c_read_operations
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_aio
+ librados/aio.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_aio PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_aio
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_list
+ librados/list.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_list PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_list
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest)
+
+add_executable(test_rados_api_pool
+ librados/pool.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_pool PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS}
+ )
+target_link_libraries(test_rados_api_pool
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_stat
+ librados/stat.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_stat PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_stat
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_watch_notify
+ librados/watch_notify.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_watch_notify PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_watch_notify
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_cls
+ librados/cls.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_cls PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_cls
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_misc
+ librados/misc.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_misc PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_misc
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+add_executable(test_rados_api_lock
+ librados/lock.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_rados_api_lock PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_rados_api_lock
+ librados
+ global
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ radostest
+ )
+
+if(${WITH_CEPHFS})
+ add_executable(test_libcephfs
+ libcephfs/test.cc
+ libcephfs/readdir_r_cb.cc
+ libcephfs/caps.cc
+ libcephfs/multiclient.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ set_target_properties(test_libcephfs PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+ target_link_libraries(test_libcephfs
+ libcephfs
+ ${UNITTEST_LIBS}
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+endif(${WITH_CEPHFS})
+
+add_executable(test_objectstore
+ objectstore/store_test.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_objectstore PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_objectstore
+ os
+ common
+ ${UNITTEST_LIBS}
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_objectstore_workloadgen
+ objectstore/workload_generator.cc
+ objectstore/TestObjectStoreState.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_objectstore_workloadgen
+ os
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_filestore_idempotent
+ objectstore/test_idempotent.cc
+ objectstore/FileStoreTracker.cc
+ common/ObjectContents.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_filestore_idempotent
+ os
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_filestore_idempotent_sequence
+ objectstore/test_idempotent_sequence.cc
+ objectstore/DeterministicOpSequence.cc
+ objectstore/TestObjectStoreState.cc
+ objectstore/FileStoreDiff.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_filestore_idempotent_sequence
+ os
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_xattr_bench
+ xattr_bench.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_xattr_bench PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_xattr_bench
+ os
+ common
+ ${UNITTEST_LIBS}
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_filejournal
+ test_filejournal.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_filejournal PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_filejournal
+ os
+ common
+ ${UNITTEST_LIBS}
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ ${EXTRALIBS}
+ )
+
+add_executable(test_stress_watch
+ test_stress_watch.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_stress_watch PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_stress_watch
+ librados
+ global
+ ${UNITTEST_LIBS}
+ radostest
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_objectcacher_stress
+ osdc/object_cacher_stress.cc
+ osdc/FakeWriteback.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_objectcacher_stress
+ osdc
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_object_map
+ ObjectMap/test_object_map.cc
+ ObjectMap/KeyValueDBMemory.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_object_map PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_object_map
+ os
+ common
+ ${UNITTEST_LIBS}
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_keyvaluedb_atomicity
+ ObjectMap/test_keyvaluedb_atomicity.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_keyvaluedb_atomicity PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_keyvaluedb_atomicity
+ os
+ common
+ ${UNITTEST_LIBS}
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+add_executable(test_keyvaluedb_iterators
+ ObjectMap/test_keyvaluedb_iterators.cc
+ ObjectMap/KeyValueDBMemory.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+set_target_properties(test_keyvaluedb_iterators PROPERTIES COMPILE_FLAGS
+ ${UNITTEST_CXX_FLAGS})
+target_link_libraries(test_keyvaluedb_iterators
+ os
+ common
+ ${UNITTEST_LIBS}
+ global
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+
+if(${WITH_FUSE})
+ add_executable(test_cfuse_cache_invalidate
+ test_cfuse_cache_invalidate.cc
+ )
+ target_link_libraries(test_cfuse_cache_invalidate
+ global
+ os
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+endif(${WITH_FUSE})
+
+if(${WITH_CEPHFS})
+ add_executable(test_c_headers
+ test_c_headers.c
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+ target_link_libraries(test_c_headers
+ librados
+ rados
+ libcephfs
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
+endif(${WITH_CEPHFS})
+
+add_executable(test_get_blkdev_size
+ test_get_blkdev_size.cc
+ $<TARGET_OBJECTS:heap_profiler_objs>
+ )
+target_link_libraries(test_get_blkdev_size
+ common
+ ${EXTRALIBS}
+ ${TCMALLOC_LIBS}
+ ${CMAKE_DL_LIBS}
+ )
projects / ceph.git / commitdiff