repo
stringlengths 1
152
⌀ | file
stringlengths 15
205
| code
stringlengths 0
41.6M
| file_length
int64 0
41.6M
| avg_line_length
float64 0
1.81M
| max_line_length
int64 0
12.7M
| extension_type
stringclasses 90
values |
|---|---|---|---|---|---|---|
null |
ceph-main/src/script/kcon_most.sh
|
#!/bin/sh -x
p() {
echo "$*" > /sys/kernel/debug/dynamic_debug/control
}
echo 9 > /proc/sysrq-trigger
p 'module ceph +p'
p 'module libceph +p'
p 'module rbd +p'
p 'file net/ceph/messenger.c -p'
p 'file' `grep -- --- /sys/kernel/debug/dynamic_debug/control | grep ceph | awk '{print $1}' | sed 's/:/ line /'` '+p'
p 'file' `grep -- === /sys/kernel/debug/dynamic_debug/control | grep ceph | awk '{print $1}' | sed 's/:/ line /'` '+p'
| 435 | 30.142857 | 118 |
sh
|
null |
ceph-main/src/script/lib-build.sh
|
#!/usr/bin/env bash
#
# lib-build.sh - A library of build and test bash shell functions.
#
# There should be few, or none, globals in this file beyond function
# definitions.
#
# This script should be `shellcheck`ed. Please run shellcheck when
# making changes to this script and use ignore comments
# (ref: https://www.shellcheck.net/wiki/Ignore ) to explicitly mark
# where a line is intentionally ignoring a typical rule.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# The following global only exists to help detect if lib-build has already been
# sourced. This is only needed because the scripts that are being migrated are
# often sourcing (as opposed to exec'ing one another).
# shellcheck disable=SC2034
_SOURCED_LIB_BUILD=1
function in_jenkins() {
[ -n "$JENKINS_HOME" ]
}
function ci_debug() {
if in_jenkins || [ "${FORCE_CI_DEBUG}" ]; then
echo "CI_DEBUG: $*"
fi
}
# get_processors returns 1/2 the value of the value returned by
# the nproc program OR the value of the environment variable NPROC
# allowing the user to tune the number of cores visible to the
# build scripts.
function get_processors() {
# get_processors() depends on coreutils nproc.
if [ -n "$NPROC" ]; then
echo "$NPROC"
else
if [ "$(nproc)" -ge 2 ]; then
echo "$(($(nproc) / 2))"
else
echo 1
fi
fi
}
# discover_compiler takes one argument, purpose, which may be used
# to adjust the results for a specific need. It sets three environment
# variables `discovered_c_compiler`, `discovered_cxx_compiler` and
# `discovered_compiler_env`. The `discovered_compiler_env` variable
# may be blank. If not, it will contain a file that needs to be sourced
# prior to using the compiler.
function discover_compiler() {
# nb: currently purpose is not used for detection
local purpose="$1"
ci_debug "Finding compiler for ${purpose}"
local compiler_env=""
local cxx_compiler=g++
local c_compiler=gcc
# ubuntu/debian ci builds prefer clang
for i in {14..10}; do
if type -t "clang-$i" > /dev/null; then
cxx_compiler="clang++-$i"
c_compiler="clang-$i"
break
fi
done
# but if this is {centos,rhel} we need gcc-toolset
if [ -f "/opt/rh/gcc-toolset-11/enable" ]; then
ci_debug "Detected SCL gcc-toolset-11 environment file"
compiler_env="/opt/rh/gcc-toolset-11/enable"
# shellcheck disable=SC1090
cxx_compiler="$(. ${compiler_env} && command -v g++)"
# shellcheck disable=SC1090
c_compiler="$(. ${compiler_env} && command -v gcc)"
fi
export discovered_c_compiler="${c_compiler}"
export discovered_cxx_compiler="${cxx_compiler}"
export discovered_compiler_env="${compiler_env}"
return 0
}
| 3,031 | 33.067416 | 79 |
sh
|
null |
ceph-main/src/script/run-cbt.sh
|
#!/bin/sh
usage() {
prog_name=$1
shift
cat <<EOF
usage:
$prog_name [options] <config-file>...
options:
-a,--archive-dir directory in which the test result is stored, default to $PWD/cbt-archive
--build-dir directory where CMakeCache.txt is located, default to $PWD
--cbt directory of cbt if you have already a copy of it. ceph/cbt:master will be cloned from github if not specified
-h,--help print this help message
--source-dir the path to the top level of Ceph source tree, default to $PWD/..
--use-existing do not setup/teardown a vstart cluster for testing
example:
$prog_name --cbt ~/dev/cbt -a /tmp ../src/test/crimson/cbt/radosbench_4K_read.yaml
EOF
}
prog_name=$(basename $0)
archive_dir=$PWD/cbt-archive
build_dir=$PWD
source_dir=$(dirname $PWD)
use_existing=false
classical=false
opts=$(getopt --options "a:h" --longoptions "archive-dir:,build-dir:,source-dir:,cbt:,help,use-existing,classical" --name $prog_name -- "$@")
eval set -- "$opts"
while true; do
case "$1" in
-a|--archive-dir)
archive_dir=$2
shift 2
;;
--build-dir)
build_dir=$2
shift 2
;;
--source-dir)
source_dir=$2
shift 2
;;
--cbt)
cbt_dir=$2
shift 2
;;
--use-existing)
use_existing=true
shift
;;
--classical)
classical=true
shift
;;
-h|--help)
usage $prog_name
return 0
;;
--)
shift
break
;;
*)
echo "unexpected argument $1" 1>&2
return 1
;;
esac
done
if test $# -gt 0; then
config_files="$@"
else
echo "$prog_name: please specify one or more .yaml files" 1>&2
usage $prog_name
return 1
fi
if test -z "$cbt_dir"; then
cbt_dir=$PWD/cbt
git clone --depth 1 -b master https://github.com/ceph/cbt.git $cbt_dir
fi
# store absolute path before changing cwd
source_dir=$(readlink -f $source_dir)
if ! $use_existing; then
cd $build_dir || exit
# seastar uses 128*8 aio in reactor for io and 10003 aio for events pooling
# for each core, if it fails to enough aio context, the seastar application
# bails out. and take other process into consideration, let's make it
# 32768 per core
max_io=$(expr 32768 \* "$(nproc)")
if test "$(/sbin/sysctl --values fs.aio-max-nr)" -lt $max_io; then
sudo /sbin/sysctl -q -w fs.aio-max-nr=$max_io
fi
if $classical; then
MDS=0 MGR=1 OSD=3 MON=1 $source_dir/src/vstart.sh -n -X \
--without-dashboard
else
MDS=0 MGR=1 OSD=3 MON=1 $source_dir/src/vstart.sh -n -X \
--without-dashboard --cyanstore \
-o "memstore_device_bytes=34359738368" \
--crimson --nodaemon --redirect-output \
--osd-args "--memory 4G"
fi
cd - || exit
fi
# i need to read the performance events,
# see https://www.kernel.org/doc/Documentation/sysctl/kernel.txt
if /sbin/capsh --supports=cap_sys_admin; then
perf_event_paranoid=$(/sbin/sysctl --values kernel.perf_event_paranoid)
if test $perf_event_paranoid -gt 0; then
sudo /sbin/sysctl -q -w kernel.perf_event_paranoid=0
fi
else
echo "without cap_sys_admin, $(whoami) cannot read the perf events"
fi
for config_file in $config_files; do
echo "testing $config_file"
cbt_config=$(mktemp $config_file.XXXX.yaml)
python3 $source_dir/src/test/crimson/cbt/t2c.py \
--build-dir $build_dir \
--input $config_file \
--output $cbt_config
python3 $cbt_dir/cbt.py \
--archive $archive_dir \
--conf $build_dir/ceph.conf \
$cbt_config
rm -f $cbt_config
done
if test -n "$perf_event_paranoid"; then
# restore the setting
sudo /sbin/sysctl -q -w kernel.perf_event_paranoid=$perf_event_paranoid
fi
if ! $use_existing; then
cd $build_dir || exit
if $classical; then
$source_dir/src/stop.sh
else
$source_dir/src/stop.sh --crimson
fi
fi
| 4,207 | 27.241611 | 141 |
sh
|
null |
ceph-main/src/script/run-make.sh
|
#!/usr/bin/env bash
set -e
if ! [ "${_SOURCED_LIB_BUILD}" = 1 ]; then
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CEPH_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
. "${CEPH_ROOT}/src/script/lib-build.sh" || exit 2
fi
trap clean_up_after_myself EXIT
ORIGINAL_CCACHE_CONF="$HOME/.ccache/ccache.conf"
SAVED_CCACHE_CONF="$HOME/.run-make-check-saved-ccache-conf"
function save_ccache_conf() {
test -f $ORIGINAL_CCACHE_CONF && cp $ORIGINAL_CCACHE_CONF $SAVED_CCACHE_CONF || true
}
function restore_ccache_conf() {
test -f $SAVED_CCACHE_CONF && mv $SAVED_CCACHE_CONF $ORIGINAL_CCACHE_CONF || true
}
function clean_up_after_myself() {
rm -fr ${CEPH_BUILD_VIRTUALENV:-/tmp}/*virtualenv*
restore_ccache_conf
}
function detect_ceph_dev_pkgs() {
local cmake_opts="-DWITH_FMT_VERSION=9.0.0"
local boost_root=/opt/ceph
if test -f $boost_root/include/boost/config.hpp; then
cmake_opts+=" -DWITH_SYSTEM_BOOST=ON -DBOOST_ROOT=$boost_root"
else
cmake_opts+=" -DBOOST_J=$(get_processors)"
fi
source /etc/os-release
if [[ "$ID" == "ubuntu" ]]; then
case "$VERSION" in
*Xenial*)
cmake_opts+=" -DWITH_RADOSGW_KAFKA_ENDPOINT=OFF";;
*Focal*)
cmake_opts+=" -DWITH_SYSTEM_ZSTD=ON";;
esac
fi
echo "$cmake_opts"
}
function prepare() {
local which_pkg="which"
if command -v apt-get > /dev/null 2>&1 ; then
which_pkg="debianutils"
fi
if test -f ./install-deps.sh ; then
ci_debug "Running install-deps.sh"
INSTALL_EXTRA_PACKAGES="ccache git $which_pkg clang"
$DRY_RUN source ./install-deps.sh || return 1
trap clean_up_after_myself EXIT
fi
if ! type ccache > /dev/null 2>&1 ; then
echo "ERROR: ccache could not be installed"
exit 1
fi
}
function configure() {
cat <<EOM
Note that the binaries produced by this script do not contain correct time
and git version information, which may make them unsuitable for debugging
and production use.
EOM
save_ccache_conf
# remove the entropy generated by the date/time embedded in the build
$DRY_RUN export SOURCE_DATE_EPOCH="946684800"
$DRY_RUN ccache -o sloppiness=time_macros
$DRY_RUN ccache -o run_second_cpp=true
if in_jenkins; then
# Build host has plenty of space available, let's use it to keep
# various versions of the built objects. This could increase the cache hit
# if the same or similar PRs are running several times
$DRY_RUN ccache -o max_size=100G
else
echo "Current ccache max_size setting:"
ccache -p | grep max_size
fi
$DRY_RUN ccache -sz # Reset the ccache statistics and show the current configuration
if ! discover_compiler ci-build ; then
ci_debug "Failed to discover a compiler"
fi
if [ "${discovered_compiler_env}" ]; then
ci_debug "Enabling compiler environment file: ${discovered_compiler_env}"
. "${discovered_compiler_env}"
fi
local cxx_compiler="${discovered_cxx_compiler}"
local c_compiler="${discovered_c_compiler}"
local cmake_opts
cmake_opts+=" -DCMAKE_CXX_COMPILER=$cxx_compiler -DCMAKE_C_COMPILER=$c_compiler"
cmake_opts+=" -DCMAKE_CXX_FLAGS_DEBUG=-Werror"
cmake_opts+=" -DENABLE_GIT_VERSION=OFF"
cmake_opts+=" -DWITH_GTEST_PARALLEL=ON"
cmake_opts+=" -DWITH_FIO=ON"
cmake_opts+=" -DWITH_CEPHFS_SHELL=ON"
cmake_opts+=" -DWITH_GRAFANA=ON"
cmake_opts+=" -DWITH_SPDK=ON"
cmake_opts+=" -DWITH_RBD_MIRROR=ON"
if [ $WITH_SEASTAR ]; then
cmake_opts+=" -DWITH_SEASTAR=ON"
fi
if [ $WITH_ZBD ]; then
cmake_opts+=" -DWITH_ZBD=ON"
fi
if [ $WITH_RBD_RWL ]; then
cmake_opts+=" -DWITH_RBD_RWL=ON"
fi
cmake_opts+=" -DWITH_RBD_SSD_CACHE=ON"
cmake_opts+=" $(detect_ceph_dev_pkgs)"
ci_debug "Our cmake_opts are: $cmake_opts"
ci_debug "Running ./configure"
ci_debug "Running do_cmake.sh"
$DRY_RUN ./do_cmake.sh $cmake_opts $@ || return 1
}
function build() {
local targets="$@"
if test -n "$targets"; then
targets="--target $targets"
fi
local bdir=build
if [ "$BUILD_DIR" ]; then
bdir="$BUILD_DIR"
fi
$DRY_RUN cd "${bdir}"
BUILD_MAKEOPTS=${BUILD_MAKEOPTS:-$DEFAULT_MAKEOPTS}
test "$BUILD_MAKEOPTS" && echo "make will run with option(s) $BUILD_MAKEOPTS"
# older cmake does not support --parallel or -j, so pass it to underlying generator
ci_debug "Running cmake"
$DRY_RUN cmake --build . $targets -- $BUILD_MAKEOPTS || return 1
$DRY_RUN ccache -s # print the ccache statistics to evaluate the efficiency
}
DEFAULT_MAKEOPTS=${DEFAULT_MAKEOPTS:--j$(get_processors)}
if [ "$0" = "$BASH_SOURCE" ]; then
# not sourced
if [ `uname` = FreeBSD ]; then
GETOPT=/usr/local/bin/getopt
else
GETOPT=getopt
fi
options=$(${GETOPT} --name "$0" --options "" --longoptions "cmake-args:" -- "$@")
if [ $? -ne 0 ]; then
exit 2
fi
eval set -- "${options}"
while true; do
case "$1" in
--cmake-args)
cmake_args=$2
shift 2;;
--)
shift
break;;
*)
echo "bad option $1" >& 2
exit 2;;
esac
done
prepare
configure "$cmake_args"
build "$@"
fi
| 5,447 | 29.099448 | 88 |
sh
|
null |
ceph-main/src/script/run_mypy.sh
|
#!/usr/bin/env bash
# needs to be executed from the src directory.
# generates a report at src/mypy_report.txt
set -e
python3 -m venv .mypy_venv
. .mypy_venv/bin/activate
! pip install $(find -name requirements.txt -not -path './frontend/*' -printf '-r%p ')
pip install mypy
MYPY_INI="$PWD"/mypy.ini
export MYPYPATH="$PWD/pybind/rados:$PWD/pybind/rbd:$PWD/pybind/cephfs"
echo -n > mypy_report.txt
pushd pybind
mypy --config-file="$MYPY_INI" *.py | awk '{print "pybind/" $0}' >> ../mypy_report.txt
popd
pushd pybind/mgr
mypy --config-file="$MYPY_INI" $(find * -name '*.py' | grep -v -e venv -e tox -e env -e gyp -e node_modules) | awk '{print "pybind/mgr/" $0}' >> ../../mypy_report.txt
popd
pushd ceph-volume/ceph_volume
mypy --config-file="$MYPY_INI" $(find * -name '*.py' | grep -v -e venv -e tox -e env -e gyp -e node_modules -e tests) | awk '{print "ceph-volume/ceph_volume/" $0}' >> ../../mypy_report.txt
popd
SORT_MYPY=$(cat <<-EOF
#!/bin/python3
import re
from collections import namedtuple
class Line(namedtuple('Line', 'prefix no rest')):
@classmethod
def parse(cls, l):
if not l:
return cls('', 0, '')
if re.search('Found [0-9]+ errors in [0-9]+ files', l):
return cls('', 0, '')
p, *rest = l.split(':', 2)
if len(rest) == 1:
return cls(p, 0, rest[0])
elif len(rest) == 2:
try:
return cls(p, int(rest[0]), rest[1])
except ValueError:
return cls(p, 0, rest[0] + ':' + rest[1])
assert False, rest
class Group(object):
def __init__(self, line):
self.line = line
self.lines = []
def matches(self, other):
return Line.parse(self.line).prefix == Line.parse(other).prefix
def __bool__(self):
return bool(self.lines) or ': note: In' not in self.line
def __str__(self):
return '\n'.join([self.line] + self.lines)
def key(self):
l1 = Line.parse(self.line)
if l1.no:
return l1.prefix, int(l1.no)
if not self.lines:
return l1.prefix, None
return l1.prefix, Line.parse(self.lines[0]).no
def parse(text):
groups = []
def group():
try:
return groups[-1]
except IndexError:
groups.append(Group(''))
return groups[-1]
for l in text:
l = l.strip()
if ': note: In' in l or not group().matches(l):
groups.append(Group(l))
elif not l:
pass
else:
group().lines.append(l)
return (g for g in groups if g)
def render(groups):
groups = sorted(groups, key=Group.key)
return '\n'.join(map(str, groups))
with open('mypy_report.txt') as f:
new = render(parse(f))
with open('mypy_report.txt', 'w') as f:
f.write(new)
EOF
)
python <(echo "$SORT_MYPY")
| 2,880 | 25.431193 | 188 |
sh
|
null |
ceph-main/src/script/run_tox.sh
|
#!/usr/bin/env bash
set -e
if [ `uname` = FreeBSD ]; then
GETOPT=/usr/local/bin/getopt
else
GETOPT=getopt
fi
function usage() {
local prog_name=$(basename $1)
shift
cat <<EOF
$prog_name [options] ... [test_name]
options:
[-h|--help] display this help message
[--source-dir dir] root source directory of Ceph. deduced by the path of this script by default.
[--build-dir dir] build directory of Ceph. "\$source_dir/build" by default.
[--tox-path dir] directory in which "tox.ini" is located. if "test_name" is not specified, it is the current directory by default, otherwise the script will try to find a directory with the name of specified \$test_name with a "tox.ini" under it.
<--tox-envs envs> tox envlist. this option is required.
[--venv-path] the python virtualenv path. \$build_dir/\$test_name by default.
example:
following command will run tox with envlist of "py3,mypy" using the "tox.ini" in current directory.
$prog_name --tox-envs py3,mypy
following command will run tox with envlist of "py3" using "/ceph/src/python-common/tox.ini"
$prog_name --tox-envs py3 --tox-path /ceph/src/python-common
EOF
}
function get_cmake_variable() {
local cmake_cache=$1/CMakeCache.txt
shift
local variable=$1
shift
if [ -e $cmake_cache ]; then
grep "$variable" $cmake_cache | cut -d "=" -f 2
fi
}
function get_tox_path() {
local test_name=$1
if [ -n "$test_name" ]; then
local found=$(find $source_dir -path "*/$test_name/tox.ini")
echo $(dirname $found)
elif [ -e tox.ini ]; then
echo $(pwd)
fi
}
function main() {
local tox_path
local script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
local build_dir=$script_dir/../../build
local source_dir=$(get_cmake_variable $build_dir ceph_SOURCE_DIR)
local tox_envs
local options
options=$(${GETOPT} --name "$0" --options 'h' --longoptions "help,source-dir:,build-dir:,tox-path:,tox-envs:,venv-path:" -- "$@")
if [ $? -ne 0 ]; then
exit 2
fi
eval set -- "${options}"
while true; do
case "$1" in
-h|--help)
usage $0
exit 0;;
--source-dir)
source_dir=$2
shift 2;;
--build-dir)
build_dir=$2
shift 2;;
--tox-path)
tox_path=$2
shift 2;;
--tox-envs)
tox_envs=$2
shift 2;;
--venv-path)
venv_path=$2
shift 2;;
--)
shift
break;;
*)
echo "bad option $1" >& 2
exit 2;;
esac
done
local test_name
if [ -z "$tox_path" ]; then
# try harder
if [ $# -gt 0 ]; then
test_name=$1
shift
fi
tox_path=$(get_tox_path $test_name)
venv_path="$build_dir/$test_name"
else
test_name=$(basename $tox_path)
fi
if [ ! -f ${venv_path}/bin/activate ]; then
if [ -d "$venv_path" ]; then
cd $venv_path
echo "$PWD already exists, but it's not a virtualenv. test_name empty?"
exit 1
fi
$source_dir/src/tools/setup-virtualenv.sh ${venv_path}
fi
source ${venv_path}/bin/activate
pip install tox
# tox.ini will take care of this.
export CEPH_BUILD_DIR=$build_dir
# use the wheelhouse prepared by install-deps.sh
export PIP_FIND_LINKS="$tox_path/wheelhouse"
tox -c $tox_path/tox.ini -e "$tox_envs" "$@"
}
main "$@"
| 3,696 | 27.007576 | 251 |
sh
|
null |
ceph-main/src/script/run_uml.sh
|
#!/bin/bash -norc
# Magic startup script for a UML instance. As long as unique
# instances are started, more than one of them can be concurrently
# in use on a single system. All their network interfaces are
# bridged together onto the virtual bridge "virbr0" which is
# supplied by the "libvirt" package.
#
# Note that a DHCP server is started for that interface. It's
# configured in this file:
# /etc/libvirt/qemu/networks/default.xml
# Unfortunately what I see there serves all possible DHCP addresses,
# so stealing them like we do here isn't really kosher. To fix
# it, that configuration should change to serve a smaller subset
# of the available address range.
#
# Each instance uses its own tun/tap device, created using the
# "tunctl" command. The assigned tap device will correspond with
# the guest id (a small integer representing the instance), i.e.,
# guest id 1 uses tap1, etc. The tap device is attached to the
# virtual bridge, which will have its own subnet associated with it.
# The guest side of that interface will have the same subnet as the
# bridge interface, with the bottom bits representing (normally) 100
# more than the guest id. So for subnet 192.168.122.0/24, guest
# id 1 will use ip 192.168.122.101, guest id 2 will use ip
# 192.168.122.102, and so on. Because these interfaces are bridged,
# they can all communicate with each other.
# You will want to override this by setting and exporting the
# "CEPH_TOP" environment variable to be the directory that contains
# the "ceph-client" source tree.
CEPH_TOP="${CEPH_TOP:-/home/elder/ceph}"
# You may want to change this too, if you want guest UML instances
# to have a diffeerent IP address range. The guest IP will be based
# on this plus GUEST_ID (defined below).
GUEST_IP_OFFSET="${GUEST_IP_OFFSET:-100}"
#############################
if [ $# -gt 1 ]; then
echo "" >&2
echo "Usage: $(basename $0) [guest_id]" >&2
echo "" >&2
echo " guest_id is a small integer (default 1)" >&2
echo " (each UML instance needs a distinct guest_id)" >&2
echo "" >&2
exit 1
elif [ $# -eq 1 ]; then
GUEST_ID="$1"
else
GUEST_ID=1
fi
# This will be what the guest host calls itself.
GUEST_HOSTNAME="uml-${GUEST_ID}"
# This is the path to the boot disk image used by UML.
DISK_IMAGE_A="${CEPH_TOP}/ceph-client/uml.${GUEST_ID}"
if [ ! -f "${DISK_IMAGE_A}" ]; then
echo "root disk image not found (or not a file)" >&2
exit 2
fi
# Hostid 1 uses tun/tap device tap1, hostid 2 uses tap2, etc.
TAP_ID="${GUEST_ID}"
# This is the tap device used for this UML instance
TAP="tap${TAP_ID}"
# This is just used to mount an image temporarily
TMP_MNT="/tmp/m$$"
# Where to put a config file generated for this tap device
TAP_IFUPDOWN_CONFIG="/tmp/interface-${TAP}"
# Compute the HOST_IP and BROADCAST address values to use,
# and assign shell variables with those names to their values.
# Also compute BITS, which is the network prefix length used.
# The NETMASK is then computed using that BITS value.
eval $(
ip addr show virbr0 | awk '
/inet/ {
split($2, a, "/")
printf("HOST_IP=%s\n", a[1]);
printf("BROADCAST=%s\n", $4);
printf("BITS=%s\n", a[2]);
exit(0);
}')
# Use bc to avoid 32-bit wrap when computing netmask
eval $(
echo -n "NETMASK="
bc <<! | fmt | sed 's/ /./g'
m = 2 ^ 32 - 2 ^ (32 - ${BITS})
for (p = 24; p >= 0; p = p - 8)
m / (2 ^ p) % 256
!
)
# Now use the netmask and the host IP to compute the subnet address
# and from that the guest IP address to use.
eval $(
awk '
function from_quad(addr, a, val, i) {
if (split(addr, a, ".") != 4)
exit(1); # address not in dotted quad format
val = 0;
for (i = 1; i <= 4; i++)
val = val * 256 + a[i];
return val;
}
function to_quad(val, addr, i) {
addr = "";
for (i = 1; i <= 4; i++) {
addr = sprintf("%u%s%s", val % 256, i > 1 ? "." : "", addr);
val = int(val / 256);
}
if ((val + 0) != 0)
exit(1); # value provided exceeded 32 bits
return addr;
}
BEGIN {
host_ip = from_quad("'${HOST_IP}'");
netmask = from_quad("'${NETMASK}'");
guest_net_ip = '${GUEST_IP_OFFSET}' + '${GUEST_ID}';
if (and(netmask, guest_net_ip))
exit(1); # address too big for subnet
subnet = and(host_ip, netmask);
guest_ip = or(subnet, guest_net_ip);
if (guest_ip == host_ip)
exit(1); # computed guest ip matches host ip
printf("SUBNET=%s\n", to_quad(subnet));
printf("GUEST_IP=%s\n", to_quad(guest_ip));
}
' < /dev/null
)
############## OK, we now know all our network parameters...
# There is a series of things that need to be done as superuser,
# so group them all into one big (and sort of nested!) sudo request.
sudo -s <<EnD_Of_sUdO
# Mount the boot disk for the UML and set up some configuration
# files there.
mkdir -p "${TMP_MNT}"
mount -o loop "${DISK_IMAGE_A}" "${TMP_MNT}"
# Arrange for loopback and eth0 to load automatically,
# and for eth0 to have our desired network parameters.
cat > "${TMP_MNT}/etc/network/interfaces" <<!
# Used by ifup(8) and ifdown(8). See the interfaces(5) manpage or
# /usr/share/doc/ifupdown/examples for more information.
auto lo
iface lo inet loopback
auto eth0
# iface eth0 inet dhcp
iface eth0 inet static
address ${GUEST_IP}
netmask ${NETMASK}
broadcast ${BROADCAST}
gateway ${HOST_IP}
!
# Have the guest start with an appropriate host name.
# Also record an entry for it in its own hosts file.
echo "${GUEST_HOSTNAME}" > "${TMP_MNT}/etc/hostname"
echo "${GUEST_IP} ${GUEST_HOSTNAME}" >> "${TMP_MNT}/etc/hosts"
# The host will serve as the name server also
cat > "${TMP_MNT}/etc/resolv.conf" <<!
nameserver ${HOST_IP}
!
# OK, done tweaking the boot image.
sync
umount "${DISK_IMAGE_A}"
rmdir "${TMP_MNT}"
# Set up a config file for "ifup" and "ifdown" (on the host) to use.
# All the backslashes below are needed because we're sitting inside
# a double here-document...
cat > "${TAP_IFUPDOWN_CONFIG}" <<!
iface ${TAP} inet manual
up brctl addif virbr0 "\\\${IFACE}"
up ip link set dev "\\\${IFACE}" up
pre-down brctl delif virbr0 "\\\${IFACE}"
pre-down ip link del dev "\\\${IFACE}"
tunctl_user $(whoami)
!
# OK, bring up the tap device using our config file
ifup -i "${TAP_IFUPDOWN_CONFIG}" "${TAP}"
EnD_Of_sUdO
# Finally ready to launch the UML instance.
./linux \
umid="${GUEST_HOSTNAME}" \
ubda="${DISK_IMAGE_A}" \
eth0="tuntap,${TAP}" \
mem=1024M
# When we're done, clean up. Bring down the tap interface and
# delete the config file.
#
# Note that if the above "./linux" crashes, you'll need to run the
# following commands manually in order to clean up state.
sudo ifdown -i "${TAP_IFUPDOWN_CONFIG}" "${TAP}"
sudo rm -f "${TAP_IFUPDOWN_CONFIG}"
exit 0
| 6,622 | 30.093897 | 68 |
sh
|
null |
ceph-main/src/script/set_up_stretch_mode.sh
|
#!/usr/bin/env bash
set -x
./bin/ceph config set osd osd_crush_update_on_start false
./bin/ceph osd crush move osd.0 host=host1-1 datacenter=site1 root=default
./bin/ceph osd crush move osd.1 host=host1-2 datacenter=site1 root=default
./bin/ceph osd crush move osd.2 host=host2-1 datacenter=site2 root=default
./bin/ceph osd crush move osd.3 host=host2-2 datacenter=site2 root=default
./bin/ceph osd getcrushmap > crush.map.bin
./bin/crushtool -d crush.map.bin -o crush.map.txt
cat <<EOF >> crush.map.txt
rule stretch_rule {
id 1
type replicated
step take site1
step chooseleaf firstn 2 type host
step emit
step take site2
step chooseleaf firstn 2 type host
step emit
}
rule stretch_rule2 {
id 2
type replicated
step take site1
step chooseleaf firstn 2 type host
step emit
step take site2
step chooseleaf firstn 2 type host
step emit
}
rule stretch_rule3 {
id 3
type replicated
step take site1
step chooseleaf firstn 2 type host
step emit
step take site2
step chooseleaf firstn 2 type host
step emit
}
EOF
./bin/crushtool -c crush.map.txt -o crush2.map.bin
./bin/ceph osd setcrushmap -i crush2.map.bin
./bin/ceph mon set election_strategy connectivity
./bin/ceph mon set_location a datacenter=site1
./bin/ceph mon set_location b datacenter=site2
./bin/ceph mon set_location c datacenter=site3
./bin/ceph osd pool create test_stretch1 1024 1024 replicated
./bin/ceph mon enable_stretch_mode c stretch_rule datacenter
| 1,613 | 28.345455 | 74 |
sh
|
null |
ceph-main/src/script/strip_trailing_whitespace.sh
|
#!/bin/sh
sed -i 's/[ \t]*$//' $1
sed -i 's/^ /\t/' $1
| 63 | 11.8 | 27 |
sh
|
null |
ceph-main/src/script/kubejacker/kubejacker.sh
|
#!/bin/bash
set -x
set -e
SCRIPT=$(readlink -f "$0")
SCRIPTPATH=$(dirname "$SCRIPT")
# Run me from your build dir! I look for binaries in bin/, lib/ etc.
BUILDPATH=$(pwd)
# PREREQUISITE: a repo that you can push to. You are probably running
# a local docker registry that your kubelet nodes also have access to.
REPO=${REPO:-"$1"}
if [ -z "$REPO" ]
then
echo "ERROR: no \$REPO set!"
echo "Run a docker repository and set REPO to <hostname>:<port>"
exit -1
fi
# The output image name: this should match whatever is configured as
# the image name in your Rook cluster CRD object.
IMAGE=ceph/ceph
TAG=latest
# The namespace where ceph containers are running in your
# test cluster: used for bouncing the containers.
NAMESPACE=rook-ceph
mkdir -p kubejacker
cp $SCRIPTPATH/Dockerfile kubejacker
# TODO: let user specify which daemon they're interested
# in -- doing all bins all the time is too slow and bloaty
#BINS="ceph-mgr ceph-mon ceph-mds ceph-osd rados radosgw-admin radosgw"
#pushd bin
#strip $BINS #TODO: make stripping optional
#tar czf $BUILDPATH/kubejacker/bin.tar.gz $BINS
#popd
# We need ceph-common to support the binaries
# We need librados/rbd to support mgr modules
# that import the python bindings
#LIBS="libceph-common.so.0 libceph-common.so librados.so.2 librados.so librados.so.2.0.0 librbd.so librbd.so.1 librbd.so.1.12.0"
#pushd lib
#strip $LIBS #TODO: make stripping optional
#tar czf $BUILDPATH/kubejacker/lib.tar.gz $LIBS
#popd
pushd ../src/python-common/ceph
tar --exclude=__pycache__ --exclude=tests -czf $BUILDPATH/kubejacker/python_common.tar.gz *
popd
pushd ../src/pybind/mgr
find ./ -name "*.pyc" -exec rm -f {} \;
# Exclude node_modules because it's the huge sources in dashboard/frontend
tar --exclude=node_modules --exclude=tests --exclude-backups -czf $BUILDPATH/kubejacker/mgr_plugins.tar.gz *
popd
#ECLIBS="libec_*.so*"
#pushd lib
#strip $ECLIBS #TODO: make stripping optional
#tar czf $BUILDPATH/kubejacker/eclib.tar.gz $ECLIBS
#popd
#CLSLIBS="libcls_*.so*"
#pushd lib
#strip $CLSLIBS #TODO: make stripping optional
#tar czf $BUILDPATH/kubejacker/clslib.tar.gz $CLSLIBS
#popd
pushd kubejacker
docker build -t $REPO/ceph/ceph:latest .
popd
# Push the image to the repository
#docker tag $REPO/$IMAGE:$TAG $REPO/$IMAGE:latest
docker push $REPO/ceph/ceph:latest
#docker push $REPO/$IMAGE:$TAG
# With a plain HTTP registry
#podman push $REPO/ceph/ceph:latest --tls-verify=false
# Finally, bounce the containers to pick up the new image
kubectl -n $NAMESPACE delete pod -l app=rook-ceph-mds
kubectl -n $NAMESPACE delete pod -l app=rook-ceph-mgr
kubectl -n $NAMESPACE delete pod -l app=rook-ceph-mon
| 2,665 | 28.955056 | 128 |
sh
|
null |
ceph-main/src/script/smr_benchmark/linearCopy.sh
|
#!/usr/bin/env bash
# copy a linear file from srcFile to destination disk in a loop until writeSize MBs is written
# destinationDisk is a SMR Host Aware Disk eg. /dev/sdb
if [ "$#" -lt 3 ]; then
echo "Usage ./linearCopy.sh srcFile destinationDisk writeSize(MB)"
exit
fi
if [ "$(id -u)" != "0" ]; then
echo "Please run as sudo user"
exit
fi
srcFile=$1
destDisk=$2
writeSize=$3
verbose=true
if [ -f time ]; then
rm -rf time
fi
#chunkSize=4096 # in bytes
chunkSize=1048576 # in bytes
fileSize=`stat --printf="%s" $srcFile`
numChunksInFile=`echo "$fileSize * (1048576 / $chunkSize)" | bc`
chunksLeft=$(( $(($writeSize * 1048576)) / $chunkSize))
echo "fileSize = $fileSize"
if [ "$(($fileSize % 512))" -ne 0 ]; then
echo "$srcFile not 512 byte aligned"
exit
fi
if [ "$(($chunkSize % 512))" -ne 0 ]; then
echo "$chunkSize not 512 byte aligned"
exit
fi
if [ "$fileSize" -lt "$chunkSize" ]; then
echo "filesize $fileSize should be greater than chunkSize $chunkSize"
exit
fi
numFileChunks=$(($fileSize / $chunkSize))
if [ $verbose == true ]; then
echo "numFileChunks = $numFileChunks"
fi
smrLBAStart=33554432 # TODO query from SMR Drive
#smrLBAStart=37224448
offset=$(( $smrLBAStart / $(( $chunkSize / 512)) ))
if [ $verbose == true ]; then
echo "chunksLeft = $chunksLeft, offset = $offset"
fi
chunkNum=0
while [ "$chunksLeft" -gt 0 ]; do
chunkNum=$(($chunkNum + 1))
if [ $verbose == true ]; then
echo "CHUNK $chunkNum `date +%H:%M:%S`" >> time
fi
dd if=$srcFile of=$destDisk seek=$offset bs=$chunkSize 2> tmp
cat tmp | grep MB >> time # > /dev/null 2>&1
if [ $verbose == true ]; then
echo "chunksLeft = $chunksLeft, offset = $offset"
fi
chunksLeft=$(($chunksLeft - $numFileChunks))
offset=$(($offset + $numFileChunks))
done
if [ -f tmp ]; then
rm tmp
fi
if [ $verbose == false ]; then
rm time
else
echo "Time Stamp for Chunk Writes"
cat time
rm time
fi
| 1,898 | 19.641304 | 94 |
sh
|
null |
ceph-main/src/script/smr_benchmark/linearSMRCopy.sh
|
#! /usr/bin/env bash
# copy a linear file from srcFile to destination SMRDisk in a loop until writeSize MBs is written
# SMRDisk is the SMR Host Aware / Host Managed Disk eg. /dev/sdb
usage(){
echo "linearSMRCopy.sh <srcFile> <SMRDisk> <writeSize (MB)>"
}
if [ "$#" -lt 3 ]; then
usage
exit
fi
if [ "$(id -u)" != "0" ]; then
echo "Please run as sudo user"
exit
fi
if which zbc_open_zone > /dev/null 2>&1 && which zbc_read_zone > /dev/null 2>&1 && which zbc_write_zone > /dev/null 2>&1 ; then
echo "libzbc commands present... refreshing zones"
# reset all write pointers before starting to write
sudo zbc_reset_write_ptr /dev/sdb -1
else
echo "libzbc commands not detected. Please install libzbc"
exit
fi
srcFile=$1
SMRDisk=$2
writeSize=$3
iosize=10240
numberOfSectors=$(($writeSize * 2048))
smrZoneStart=33554432 # TODO query this from SMR drive
#dd if=$srcFile of=$destDisk seek=$smrZoneStart bs=512
fileSize=`stat --printf="%s" $srcFile`
if [ "$(($fileSize % 512))" -ne 0 ]; then
echo "$srcFile not 512 byte aligned"
exit
fi
sectorsLeftToWrite=$(($fileSize / 512))
znum=64 # TODO query this from SMR Drive
zoneLength=524288 # number of sectors in each zone TODO query from SMR drive
writeOffset=$smrZoneStart
sectorsLeftToWrite=$numberOfSectors
echo "write begin sectors Left = $sectorsLeftToWrite, writeOffset = $writeOffset zone Num = $znum"
while [ "$sectorsLeftToWrite" -gt 0 ];
do
sudo zbc_open_zone $SMRDisk $znum
sudo time zbc_write_zone -f $srcFile -loop $SMRDisk $znum $iosize
sudo zbc_close_zone /dev/sdb $znum
writeOffset=$(($writeOffset+$zoneLength))
znum=$(($znum+1))
sectorsLeftToWrite=$(($sectorsLeftToWrite - $zoneLength))
done
echo "write end sectors Left = $sectorsLeftToWrite, writeOffset = $writeOffset zone Num = $znum"
| 1,789 | 24.571429 | 127 |
sh
|
null |
ceph-main/src/test/TestSignalHandlers.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2010 Dreamhost
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
/*
* TestSignalHandlers
*
* Test the Ceph signal handlers
*/
#include "common/ceph_argparse.h"
#include "global/global_init.h"
#include "common/errno.h"
#include "common/debug.h"
#include "common/config.h"
#include <errno.h>
#include <iostream>
#include <sstream>
#include <string>
#define dout_context g_ceph_context
using namespace std;
// avoid compiler warning about dereferencing NULL pointer
static int* get_null()
{
return 0;
}
static void simple_segv_test()
{
generic_dout(-1) << "triggering SIGSEGV..." << dendl;
// cppcheck-suppress nullPointer
int i = *get_null();
std::cout << "i = " << i << std::endl;
}
// Given the name of the function, we can be pretty sure this is intentional.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Winfinite-recursion"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winfinite-recursion"
static void infinite_recursion_test_impl()
{
infinite_recursion_test_impl();
}
#pragma GCC diagnostic pop
#pragma clang diagnostic pop
static void infinite_recursion_test()
{
generic_dout(0) << "triggering SIGSEGV with infinite recursion..." << dendl;
infinite_recursion_test_impl();
}
static void usage()
{
cout << "usage: TestSignalHandlers [test]" << std::endl;
cout << "--simple_segv: run simple_segv test" << std::endl;
cout << "--infinite_recursion: run infinite_recursion test" << std::endl;
generic_client_usage();
}
typedef void (*test_fn_t)(void);
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
if (args.empty()) {
cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
}
if (ceph_argparse_need_usage(args)) {
usage();
exit(0);
}
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
test_fn_t fn = NULL;
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
} else if (ceph_argparse_flag(args, i, "--infinite_recursion", (char*)NULL)) {
fn = infinite_recursion_test;
} else if (ceph_argparse_flag(args, i, "-s", "--simple_segv", (char*)NULL)) {
fn = simple_segv_test;
} else {
cerr << "unrecognized argument: " << *i << std::endl;
exit(1);
}
}
if (!fn) {
std::cerr << "Please select a test to run. Type -h for help." << std::endl;
exit(1);
}
fn();
return 0;
}
| 2,911 | 23.677966 | 82 |
cc
|
null |
ceph-main/src/test/TestTimers.cc
|
#include "common/ceph_argparse.h"
#include "common/ceph_mutex.h"
#include "common/Timer.h"
#include "global/global_init.h"
#include "include/Context.h"
#include <iostream>
/*
* TestTimers
*
* Tests the timer classes
*/
#define MAX_TEST_CONTEXTS 5
using namespace std;
class TestContext;
namespace
{
int test_array[MAX_TEST_CONTEXTS];
int array_idx;
TestContext* test_contexts[MAX_TEST_CONTEXTS];
ceph::mutex array_lock = ceph::make_mutex("test_timers_mutex");
}
class TestContext : public Context
{
public:
explicit TestContext(int num_)
: num(num_)
{
}
void finish(int r) override
{
std::lock_guard locker{array_lock};
cout << "TestContext " << num << std::endl;
test_array[array_idx++] = num;
}
~TestContext() override
{
}
protected:
int num;
};
class StrictOrderTestContext : public TestContext
{
public:
explicit StrictOrderTestContext (int num_)
: TestContext(num_)
{
}
void finish(int r) override
{
std::lock_guard locker{array_lock};
cout << "StrictOrderTestContext " << num << std::endl;
test_array[num] = num;
}
~StrictOrderTestContext() override
{
}
};
static void print_status(const char *str, int ret)
{
cout << str << ": ";
cout << ((ret == 0) ? "SUCCESS" : "FAILURE");
cout << std::endl;
}
template <typename T>
static int basic_timer_test(T &timer, ceph::mutex *lock)
{
int ret = 0;
memset(&test_array, 0, sizeof(test_array));
array_idx = 0;
memset(&test_contexts, 0, sizeof(test_contexts));
cout << __PRETTY_FUNCTION__ << std::endl;
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
test_contexts[i] = new TestContext(i);
}
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
if (lock)
lock->lock();
auto t = ceph::real_clock::now() + std::chrono::seconds(2 * i);
timer.add_event_at(t, test_contexts[i]);
if (lock)
lock->unlock();
}
bool done = false;
do {
sleep(1);
std::lock_guard locker{array_lock};
done = (array_idx == MAX_TEST_CONTEXTS);
} while (!done);
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
if (test_array[i] != i) {
ret = 1;
cout << "error: expected test_array[" << i << "] = " << i
<< "; got " << test_array[i] << " instead." << std::endl;
}
}
return ret;
}
static int test_out_of_order_insertion(SafeTimer &timer, ceph::mutex *lock)
{
int ret = 0;
memset(&test_array, 0, sizeof(test_array));
array_idx = 0;
memset(&test_contexts, 0, sizeof(test_contexts));
cout << __PRETTY_FUNCTION__ << std::endl;
test_contexts[0] = new StrictOrderTestContext(0);
test_contexts[1] = new StrictOrderTestContext(1);
{
auto t = ceph::real_clock::now() + 100s;
std::lock_guard locker{*lock};
timer.add_event_at(t, test_contexts[0]);
}
{
auto t = ceph::real_clock::now() + 2s;
std::lock_guard locker{*lock};
timer.add_event_at(t, test_contexts[1]);
}
int secs = 0;
for (; secs < 100 ; ++secs) {
sleep(1);
array_lock.lock();
int a = test_array[1];
array_lock.unlock();
if (a == 1)
break;
}
if (secs == 100) {
ret = 1;
cout << "error: expected test_array[" << 1 << "] = " << 1
<< "; got " << test_array[1] << " instead." << std::endl;
}
return ret;
}
static int safe_timer_cancel_all_test(SafeTimer &safe_timer,
ceph::mutex& safe_timer_lock)
{
cout << __PRETTY_FUNCTION__ << std::endl;
int ret = 0;
memset(&test_array, 0, sizeof(test_array));
array_idx = 0;
memset(&test_contexts, 0, sizeof(test_contexts));
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
test_contexts[i] = new TestContext(i);
}
safe_timer_lock.lock();
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
auto t = ceph::real_clock::now() + std::chrono::seconds(4 * i);
safe_timer.add_event_at(t, test_contexts[i]);
}
safe_timer_lock.unlock();
sleep(10);
safe_timer_lock.lock();
safe_timer.cancel_all_events();
safe_timer_lock.unlock();
for (int i = 0; i < array_idx; ++i) {
if (test_array[i] != i) {
ret = 1;
cout << "error: expected test_array[" << i << "] = " << i
<< "; got " << test_array[i] << " instead." << std::endl;
}
}
return ret;
}
static int safe_timer_cancellation_test(SafeTimer &safe_timer,
ceph::mutex& safe_timer_lock)
{
cout << __PRETTY_FUNCTION__ << std::endl;
int ret = 0;
memset(&test_array, 0, sizeof(test_array));
array_idx = 0;
memset(&test_contexts, 0, sizeof(test_contexts));
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
test_contexts[i] = new StrictOrderTestContext(i);
}
safe_timer_lock.lock();
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
auto t = ceph::real_clock::now() + std::chrono::seconds(4 * i);
safe_timer.add_event_at(t, test_contexts[i]);
}
safe_timer_lock.unlock();
// cancel the even-numbered events
for (int i = 0; i < MAX_TEST_CONTEXTS; i += 2) {
safe_timer_lock.lock();
safe_timer.cancel_event(test_contexts[i]);
safe_timer_lock.unlock();
}
sleep(20);
safe_timer_lock.lock();
safe_timer.cancel_all_events();
safe_timer_lock.unlock();
for (int i = 1; i < array_idx; i += 2) {
if (test_array[i] != i) {
ret = 1;
cout << "error: expected test_array[" << i << "] = " << i
<< "; got " << test_array[i] << " instead." << std::endl;
}
}
return ret;
}
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
int ret;
ceph::mutex safe_timer_lock = ceph::make_mutex("safe_timer_lock");
SafeTimer safe_timer(g_ceph_context, safe_timer_lock);
safe_timer.init();
ret = basic_timer_test <SafeTimer>(safe_timer, &safe_timer_lock);
if (ret)
goto done;
ret = safe_timer_cancel_all_test(safe_timer, safe_timer_lock);
if (ret)
goto done;
ret = safe_timer_cancellation_test(safe_timer, safe_timer_lock);
if (ret)
goto done;
ret = test_out_of_order_insertion(safe_timer, &safe_timer_lock);
if (ret)
goto done;
done:
safe_timer.shutdown();
print_status(argv[0], ret);
return ret;
}
| 6,307 | 21.368794 | 75 |
cc
|
null |
ceph-main/src/test/admin_socket.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/ceph_mutex.h"
#include "common/Cond.h"
#include "common/admin_socket.h"
#include "common/admin_socket_client.h"
#include "common/ceph_argparse.h"
#include "gtest/gtest.h"
#include <stdint.h>
#include <string.h>
#include <string>
#include <sys/un.h>
using namespace std;
class AdminSocketTest
{
public:
explicit AdminSocketTest(AdminSocket *asokc)
: m_asokc(asokc)
{
}
bool init(const std::string &uri) {
return m_asokc->init(uri);
}
string bind_and_listen(const std::string &sock_path, int *fd) {
return m_asokc->bind_and_listen(sock_path, fd);
}
bool shutdown() {
m_asokc->shutdown();
return true;
}
AdminSocket *m_asokc;
};
TEST(AdminSocket, Teardown) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
}
TEST(AdminSocket, TeardownSetup) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
ASSERT_EQ(true, asoct.init(get_rand_socket_path()));
ASSERT_EQ(true, asoct.shutdown());
}
TEST(AdminSocket, SendHelp) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
ASSERT_EQ(true, asoct.init(get_rand_socket_path()));
AdminSocketClient client(get_rand_socket_path());
{
string help;
ASSERT_EQ("", client.do_request("{\"prefix\":\"help\"}", &help));
ASSERT_NE(string::npos, help.find("\"list available commands\""));
}
{
string help;
ASSERT_EQ("", client.do_request("{"
" \"prefix\":\"help\","
" \"format\":\"xml\","
"}", &help));
ASSERT_NE(string::npos, help.find(">list available commands<"));
}
{
string help;
ASSERT_EQ("", client.do_request("{"
" \"prefix\":\"help\","
" \"format\":\"UNSUPPORTED\","
"}", &help));
ASSERT_NE(string::npos, help.find("\"list available commands\""));
}
ASSERT_EQ(true, asoct.shutdown());
}
TEST(AdminSocket, SendNoOp) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
ASSERT_EQ(true, asoct.init(get_rand_socket_path()));
AdminSocketClient client(get_rand_socket_path());
string version;
ASSERT_EQ("", client.do_request("{\"prefix\":\"0\"}", &version));
ASSERT_EQ(CEPH_ADMIN_SOCK_VERSION, version);
ASSERT_EQ(true, asoct.shutdown());
}
TEST(AdminSocket, SendTooLongRequest) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
ASSERT_EQ(true, asoct.init(get_rand_socket_path()));
AdminSocketClient client(get_rand_socket_path());
string version;
string request(16384, 'a');
//if admin_socket cannot handle it, segfault will happened.
ASSERT_NE("", client.do_request(request, &version));
ASSERT_EQ(true, asoct.shutdown());
}
class MyTest : public AdminSocketHook {
int call(std::string_view command, const cmdmap_t& cmdmap,
const bufferlist&,
Formatter *f,
std::ostream& ss,
bufferlist& result) override {
std::vector<std::string> args;
TOPNSPC::common::cmd_getval(cmdmap, "args", args);
result.append(command);
result.append("|");
string resultstr;
for (std::vector<std::string>::iterator it = args.begin();
it != args.end(); ++it) {
if (it != args.begin())
resultstr += ' ';
resultstr += *it;
}
result.append(resultstr);
return 0;
}
};
TEST(AdminSocket, RegisterCommand) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
std::unique_ptr<AdminSocketHook> my_test_asok = std::make_unique<MyTest>();
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
ASSERT_EQ(true, asoct.init(get_rand_socket_path()));
AdminSocketClient client(get_rand_socket_path());
ASSERT_EQ(0, asoct.m_asokc->register_command("test", my_test_asok.get(), ""));
string result;
ASSERT_EQ("", client.do_request("{\"prefix\":\"test\"}", &result));
ASSERT_EQ("test|", result);
ASSERT_EQ(true, asoct.shutdown());
}
class MyTest2 : public AdminSocketHook {
int call(std::string_view command, const cmdmap_t& cmdmap,
const bufferlist&,
Formatter *f,
std::ostream& ss,
bufferlist& result) override {
std::vector<std::string> args;
TOPNSPC::common::cmd_getval(cmdmap, "args", args);
result.append(command);
result.append("|");
string resultstr;
for (std::vector<std::string>::iterator it = args.begin();
it != args.end(); ++it) {
if (it != args.begin())
resultstr += ' ';
resultstr += *it;
}
result.append(resultstr);
ss << "error stream";
return 0;
}
};
TEST(AdminSocket, RegisterCommandPrefixes) {
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
std::unique_ptr<AdminSocketHook> my_test_asok = std::make_unique<MyTest>();
std::unique_ptr<AdminSocketHook> my_test2_asok = std::make_unique<MyTest2>();
AdminSocketTest asoct(asokc.get());
ASSERT_EQ(true, asoct.shutdown());
ASSERT_EQ(true, asoct.init(get_rand_socket_path()));
AdminSocketClient client(get_rand_socket_path());
ASSERT_EQ(0, asoct.m_asokc->register_command("test name=args,type=CephString,n=N", my_test_asok.get(), ""));
ASSERT_EQ(0, asoct.m_asokc->register_command("test command name=args,type=CephString,n=N", my_test2_asok.get(), ""));
string result;
ASSERT_EQ("", client.do_request("{\"prefix\":\"test\"}", &result));
ASSERT_EQ("test|", result);
ASSERT_EQ("", client.do_request("{\"prefix\":\"test command\"}", &result));
ASSERT_EQ("test command|", result);
ASSERT_EQ("", client.do_request("{\"prefix\":\"test command\",\"args\":[\"post\"]}", &result));
ASSERT_EQ("test command|post", result);
ASSERT_EQ("", client.do_request("{\"prefix\":\"test command\",\"args\":[\" post\"]}", &result));
ASSERT_EQ("test command| post", result);
ASSERT_EQ("", client.do_request("{\"prefix\":\"test\",\"args\":[\"this thing\"]}", &result));
ASSERT_EQ("test|this thing", result);
ASSERT_EQ("", client.do_request("{\"prefix\":\"test\",\"args\":[\" command post\"]}", &result));
ASSERT_EQ("test| command post", result);
ASSERT_EQ("", client.do_request("{\"prefix\":\"test\",\"args\":[\" this thing\"]}", &result));
ASSERT_EQ("test| this thing", result);
ASSERT_EQ(true, asoct.shutdown());
}
class BlockingHook : public AdminSocketHook {
public:
ceph::mutex _lock = ceph::make_mutex("BlockingHook::_lock");
ceph::condition_variable _cond;
BlockingHook() = default;
int call(std::string_view command, const cmdmap_t& cmdmap,
const bufferlist&,
Formatter *f,
std::ostream& ss,
bufferlist& result) override {
std::unique_lock l{_lock};
_cond.wait(l);
return 0;
}
};
TEST(AdminSocketClient, Ping) {
string path = get_rand_socket_path();
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketClient client(path);
// no socket
{
bool ok;
std::string result = client.ping(&ok);
#ifndef _WIN32
// TODO: convert WSA errors.
EXPECT_NE(std::string::npos, result.find("No such file or directory"));
#endif
ASSERT_FALSE(ok);
}
// file exists but does not allow connections (no process, wrong type...)
int fd = ::creat(path.c_str(), 0777);
ASSERT_TRUE(fd);
// On Windows, we won't be able to remove the file unless we close it
// first.
ASSERT_FALSE(::close(fd));
{
bool ok;
std::string result = client.ping(&ok);
#ifndef _WIN32
#if defined(__APPLE__) || defined(__FreeBSD__)
const char* errmsg = "Socket operation on non-socket";
#else
const char* errmsg = "Connection refused";
#endif
EXPECT_NE(std::string::npos, result.find(errmsg));
#endif /* _WIN32 */
ASSERT_FALSE(ok);
}
// a daemon is connected to the socket
{
AdminSocketTest asoct(asokc.get());
ASSERT_TRUE(asoct.init(path));
bool ok;
std::string result = client.ping(&ok);
EXPECT_EQ("", result);
ASSERT_TRUE(ok);
ASSERT_TRUE(asoct.shutdown());
}
// hardcoded five seconds timeout prevents infinite blockage
{
AdminSocketTest asoct(asokc.get());
BlockingHook *blocking = new BlockingHook();
ASSERT_EQ(0, asoct.m_asokc->register_command("0", blocking, ""));
ASSERT_TRUE(asoct.init(path));
bool ok;
std::string result = client.ping(&ok);
#ifndef _WIN32
EXPECT_NE(std::string::npos, result.find("Resource temporarily unavailable"));
#endif
ASSERT_FALSE(ok);
{
std::lock_guard l{blocking->_lock};
blocking->_cond.notify_all();
}
ASSERT_TRUE(asoct.shutdown());
delete blocking;
}
}
TEST(AdminSocket, bind_and_listen) {
string path = get_rand_socket_path();
std::unique_ptr<AdminSocket> asokc = std::make_unique<AdminSocket>(g_ceph_context);
AdminSocketTest asoct(asokc.get());
// successfull bind
{
int fd = 0;
string message;
message = asoct.bind_and_listen(path, &fd);
ASSERT_NE(0, fd);
ASSERT_EQ("", message);
ASSERT_EQ(0, ::compat_closesocket(fd));
ASSERT_EQ(0, ::unlink(path.c_str()));
}
// silently discard an existing file
{
int fd = 0;
string message;
int fd2 = ::creat(path.c_str(), 0777);
ASSERT_TRUE(fd2);
// On Windows, we won't be able to remove the file unless we close it
// first.
ASSERT_FALSE(::close(fd2));
message = asoct.bind_and_listen(path, &fd);
ASSERT_NE(0, fd);
ASSERT_EQ("", message);
ASSERT_EQ(0, ::compat_closesocket(fd));
ASSERT_EQ(0, ::unlink(path.c_str()));
}
// do not take over a live socket
{
ASSERT_TRUE(asoct.init(path));
int fd = 0;
string message;
message = asoct.bind_and_listen(path, &fd);
std::cout << "message: " << message << std::endl;
EXPECT_NE(std::string::npos, message.find("File exists"));
ASSERT_TRUE(asoct.shutdown());
}
}
/*
* Local Variables:
* compile-command: "cd .. ;
* make unittest_admin_socket &&
* valgrind \
* --max-stackframe=20000000 --tool=memcheck \
* ./unittest_admin_socket --debug-asok 20 # --gtest_filter=AdminSocket*.*
* "
* End:
*/
| 10,771 | 30.497076 | 119 |
cc
|
null |
ceph-main/src/test/admin_socket_output.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2017 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <iostream>
#include <regex> // For regex, regex_search
#include "common/admin_socket_client.h" // For AdminSocketClient
#include "common/ceph_json.h" // For JSONParser, JSONObjIter
#include "include/buffer.h" // For bufferlist
#include "admin_socket_output.h"
using namespace std;
void AdminSocketOutput::add_target(const std::string& target) {
if (target == "all") {
add_target("osd");
add_target("mon");
add_target("mgr");
add_target("mds");
add_target("client");
return;
}
targets.insert(target);
}
void AdminSocketOutput::add_command(const std::string& target,
const std::string& command) {
auto seek = custom_commands.find(target);
if (seek != custom_commands.end()) {
seek->second.push_back(command);
} else {
std::vector<std::string> vec;
vec.push_back(command);
custom_commands.insert(std::make_pair(target, vec));
}
}
void AdminSocketOutput::add_test(const std::string &target,
const std::string &command,
bool (*test)(std::string &)) {
auto seek = tests.find(target);
if (seek != tests.end()) {
seek->second.push_back(std::make_pair(command, test));
} else {
std::vector<std::pair<std::string, bool (*)(std::string &)>> vec;
vec.push_back(std::make_pair(command, test));
tests.insert(std::make_pair(target, vec));
}
}
void AdminSocketOutput::postpone(const std::string &target,
const std::string& command) {
auto seek = postponed_commands.find(target);
if (seek != postponed_commands.end()) {
seek->second.push_back(command);
} else {
std::vector<string> vec;
vec.push_back(command);
postponed_commands.insert(std::make_pair(target, vec));
}
}
bool AdminSocketOutput::init_sockets() {
std::cout << "Initialising sockets" << std::endl;
std::string socket_regex = R"(\..*\.asok)";
for (const auto &x : fs::recursive_directory_iterator(socketdir)) {
std::cout << x.path() << std::endl;
if (x.path().extension() == ".asok") {
for (auto target = targets.cbegin(); target != targets.cend();) {
std::regex reg(prefix + *target + socket_regex);
if (std::regex_search(x.path().filename().string(), reg)) {
std::cout << "Found " << *target << " socket " << x.path()
<< std::endl;
sockets.insert(std::make_pair(*target, x.path().string()));
target = targets.erase(target);
}
else {
++target;
}
}
if (targets.empty()) {
std::cout << "Found all required sockets" << std::endl;
break;
}
}
}
return !sockets.empty() && targets.empty();
}
std::pair<std::string, std::string>
AdminSocketOutput::run_command(AdminSocketClient &client,
const std::string &raw_command,
bool send_untouched) {
std::cout << "Sending command \"" << raw_command << "\"" << std::endl;
std::string command;
std::string output;
if (send_untouched) {
command = raw_command;
} else {
command = "{\"prefix\":\"" + raw_command + "\"}";
}
std::string err = client.do_request(command, &output);
if (!err.empty()) {
std::cerr << __func__ << " AdminSocketClient::do_request errored with: "
<< err << std::endl;
ceph_abort();
}
return std::make_pair(command, output);
}
bool AdminSocketOutput::gather_socket_output() {
std::cout << "Gathering socket output" << std::endl;
for (const auto& socket : sockets) {
std::string response;
AdminSocketClient client(socket.second);
std::cout << std::endl
<< "Sending request to " << socket << std::endl
<< std::endl;
std::string err = client.do_request("{\"prefix\":\"help\"}", &response);
if (!err.empty()) {
std::cerr << __func__ << " AdminSocketClient::do_request errored with: "
<< err << std::endl;
return false;
}
std::cout << response << '\n';
JSONParser parser;
bool ret = parser.parse(response.c_str(), response.size());
if (!ret) {
cerr << "parse error" << std::endl;
return false;
}
socket_results sresults;
JSONObjIter iter = parser.find_first();
const auto postponed_iter = postponed_commands.find(socket.first);
std::vector<std::string> postponed;
if (postponed_iter != postponed_commands.end()) {
postponed = postponed_iter->second;
}
std::cout << "Sending commands to " << socket.first << " socket"
<< std::endl;
for (; !iter.end(); ++iter) {
if (std::find(postponed.begin(), postponed.end(), (*iter)->get_name())
!= std::end(postponed)) {
std::cout << "Command \"" << (*iter)->get_name() << "\" postponed"
<< std::endl;
continue;
}
sresults.insert(run_command(client, (*iter)->get_name()));
}
if (sresults.empty()) {
return false;
}
// Custom commands
const auto seek = custom_commands.find(socket.first);
if (seek != custom_commands.end()) {
std::cout << std::endl << "Sending custom commands:" << std::endl;
for (const auto& raw_command : seek->second) {
sresults.insert(run_command(client, raw_command, true));
}
}
// Postponed commands
if (!postponed.empty())
std::cout << std::endl << "Sending postponed commands" << std::endl;
for (const auto& command : postponed) {
sresults.insert(run_command(client, command));
}
results.insert(
std::pair<std::string, socket_results>(socket.first, sresults));
}
return true;
}
std::string AdminSocketOutput::get_result(const std::string &target,
const std::string &command) const {
const auto& target_results = results.find(target);
if (target_results == results.end())
return std::string("");
else {
const auto& result = target_results->second.find(command);
if (result == target_results->second.end())
return std::string("");
else
return result->second;
}
}
bool AdminSocketOutput::run_tests() const {
for (const auto& socket : sockets) {
const auto& seek = tests.find(socket.first);
if (seek != tests.end()) {
std::cout << std::endl;
std::cout << "Running tests for " << socket.first << " socket" << std::endl;
for (const auto& test : seek->second) {
auto result = get_result(socket.first, test.first);
if(result.empty()) {
std::cout << "Failed to find result for command: " << test.first << std::endl;
return false;
} else {
std::cout << "Running test for command: " << test.first << std::endl;
const auto& test_func = test.second;
bool res = test_func(result);
if (res == false)
return false;
else
std::cout << "Test passed" << std::endl;
}
}
}
}
return true;
}
void AdminSocketOutput::exec() {
ceph_assert(init_directories());
ceph_assert(init_sockets());
ceph_assert(gather_socket_output());
ceph_assert(run_tests());
}
| 7,700 | 30.691358 | 90 |
cc
|
null |
ceph-main/src/test/admin_socket_output.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2017 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_ADMIN_SOCKET_OUTPUT_H
#define CEPH_ADMIN_SOCKET_OUTPUT_H
#include <filesystem>
#include <string>
#include <map>
#include <set>
#include <vector>
namespace fs = std::filesystem;
using socket_results = std::map<std::string, std::string>;
using test_functions =
std::vector<std::pair<std::string, bool (*)(std::string &)>>;
class AdminSocketClient;
class AdminSocketOutput {
public:
AdminSocketOutput() {}
void add_target(const std::string &target);
void add_command(const std::string &target, const std::string &command);
void add_test(const std::string &target, const std::string &command,
bool (*test)(std::string &));
void postpone(const std::string &target, const std::string &command);
void exec();
void mod_for_vstart(const std::string& dir) {
socketdir = dir;
prefix = "";
}
private:
bool init_directories() const {
std::cout << "Checking " << socketdir << std::endl;
return exists(socketdir) && is_directory(socketdir);
}
bool init_sockets();
bool gather_socket_output();
std::string get_result(const std::string &target, const std::string &command) const;
std::pair<std::string, std::string>
run_command(AdminSocketClient &client, const std::string &raw_command,
bool send_untouched = false);
bool run_tests() const;
std::set<std::string> targets;
std::map<std::string, std::string> sockets;
std::map<std::string, socket_results> results;
std::map<std::string, std::vector<std::string>> custom_commands;
std::map<std::string, std::vector<std::string>> postponed_commands;
std::map<std::string, test_functions> tests;
std::string prefix = "ceph-";
fs::path socketdir = "/var/run/ceph";
};
#endif // CEPH_ADMIN_SOCKET_OUTPUT_H
| 2,157 | 27.025974 | 86 |
h
|
null |
ceph-main/src/test/admin_socket_output_tests.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2017 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <string>
#include <iostream>
#include "common/ceph_json.h"
// Test functions
// Example test function
/*
bool test_config_get_admin_socket(std::string& output) {
return std::string::npos != output.find("admin_socket") &&
std::string::npos != output.rfind(".asok");
}
*/
bool test_dump_pgstate_history(std::string &output) {
JSONParser parser;
bool ret = parser.parse(output.c_str(), output.size());
if (!ret) {
std::cerr << "test_dump_pgstate_history: parse error" << std::endl;
return false;
}
JSONObjIter iterone = parser.find_first();
if (iterone.end()) { //Empty
std::cerr << "test_dump_pgstate_history: command output empty, failing"
<< std::endl;
return false;
}
unsigned int total = 0;
if ((*iterone)->get_name() == "pgs") {
JSONObjIter iter = (*(*iterone)->find_first())->find_first();
for (; !iter.end(); ++iter) {
if ((*iter)->get_name() == "pg") {
ret = !(*iter)->get_data().empty();
if (ret == false) {
std::cerr << "test_dump_pgstate_history: pg value empty, failing"
<< std::endl;
std::cerr << "Dumping full output: " << std::endl;
std::cerr << output << std::endl;
break;
}
total++;
} else if ((*iter)->get_name() == "history") {
ret = std::string::npos != (*iter)->get_data().find("epoch") &&
std::string::npos != (*iter)->get_data().find("state") &&
std::string::npos != (*iter)->get_data().find("enter") &&
std::string::npos != (*iter)->get_data().find("exit");
if (ret == false) {
std::cerr << "test_dump_pgstate_history: Can't find expected values in "
"history object, failing"
<< std::endl;
std::cerr << "Problem output was:" << std::endl;
std::cerr << (*iter)->get_data() << std::endl;
break;
}
total++;
} else if ((*iter)->get_name() == "currently") {
ret = !(*iter)->get_data().empty();
if (ret == false) {
std::cerr << "test_dump_pgstate_history: currently value empty, failing"
<< std::endl;
std::cerr << "Dumping full output: " << std::endl;
std::cerr << output << std::endl;
break;
}
total++;
} else {
std::cerr << "test_dump_pgstate_history: unrecognised field " << (*iter)->get_name()
<< ", failing" << std::endl;
std::cerr << "Dumping full output: " << std::endl;
std::cerr << output << std::endl;
break;
}
}
} else {
std::cerr << "test_dump_pgstate_history: unrecognised format, failing"
<< std::endl;
std::cerr << "Dumping full output: " << std::endl;
std::cerr << output << std::endl;
return false;
}
if (total != 3) {
std::cerr << "Could not find required elements, failing" << std::endl;
std::cerr << "Dumping full output: " << std::endl;
std::cerr << output << std::endl;
return false;
}
return ret;
}
| 3,504 | 31.453704 | 92 |
cc
|
null |
ceph-main/src/test/admin_socket_output_tests.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2017 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_ADMIN_SOCKET_OUTPUT_TESTS_H
#define CEPH_ADMIN_SOCKET_OUTPUT_TESTS_H
// Test function declarations, definitions in admin_socket_output_tests.cc
// Example test function
/*
bool test_config_get_admin_socket(std::string& output);
*/
bool test_dump_pgstate_history(std::string& output);
#endif // CEPH_ADMIN_SOCKET_OUTPUT_TESTS_H
| 744 | 24.689655 | 74 |
h
|
null |
ceph-main/src/test/barclass.cc
|
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include "objclass/objclass.h"
CLS_VER(1,0)
CLS_NAME(bar)
cls_handle_t h_class;
cls_method_handle_t h_foo;
int foo_method(cls_method_context_t ctx, char *indata, int datalen,
char **outdata, int *outdatalen)
{
int i;
cls_log("hello world, this is bar");
cls_log("indata=%s", indata);
*outdata = (char *)malloc(128);
for (i=0; i<strlen(indata) + 1; i++) {
if (indata[i] == '0') {
(*outdata)[i] = '*';
} else {
(*outdata)[i] = indata[i];
}
}
*outdatalen = strlen(*outdata) + 1;
cls_log("outdata=%s", *outdata);
return 0;
}
void class_init()
{
cls_log("Loaded bar class!");
cls_register("bar", &h_class);
cls_register_method(h_class, "bar", foo_method, &h_foo);
return;
}
| 817 | 15.693878 | 67 |
cc
|
null |
ceph-main/src/test/base64.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 Dreamhost
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/armor.h"
#include "common/config.h"
#include "include/buffer.h"
#include "include/encoding.h"
#include "gtest/gtest.h"
using namespace std;
TEST(RoundTrip, SimpleRoundTrip) {
static const int OUT_LEN = 4096;
const char * const original = "abracadabra";
const char * const correctly_encoded = "YWJyYWNhZGFicmE=";
char out[OUT_LEN];
memset(out, 0, sizeof(out));
int alen = ceph_armor(out, out + OUT_LEN, original, original + strlen(original));
ASSERT_STREQ(correctly_encoded, out);
char out2[OUT_LEN];
memset(out2, 0, sizeof(out2));
ceph_unarmor(out2, out2 + OUT_LEN, out, out + alen);
ASSERT_STREQ(original, out2);
}
TEST(RoundTrip, RandomRoundTrips) {
static const int IN_MAX = 1024;
static const int OUT_MAX = 4096;
static const int ITERS = 1000;
for (int i = 0; i < ITERS; ++i) {
unsigned int seed = i;
int in_len = rand_r(&seed) % IN_MAX;
char in[IN_MAX];
memset(in, 0, sizeof(in));
for (int j = 0; j < in_len; ++j) {
in[j] = rand_r(&seed) % 0xff;
}
char out[OUT_MAX];
memset(out, 0, sizeof(out));
int alen = ceph_armor(out, out + OUT_MAX, in, in + in_len);
ASSERT_GE(alen, 0);
char decoded[IN_MAX];
memset(decoded, 0, sizeof(decoded));
int blen = ceph_unarmor(decoded, decoded + IN_MAX, out, out + alen);
ASSERT_GE(blen, 0);
ASSERT_EQ(memcmp(in, decoded, in_len), 0);
}
}
TEST(EdgeCase, EndsInNewline) {
static const int OUT_MAX = 4096;
char b64[] =
"aaaa\n";
char decoded[OUT_MAX];
memset(decoded, 0, sizeof(decoded));
int blen = ceph_unarmor(decoded, decoded + OUT_MAX, b64, b64 + sizeof(b64)-1);
ASSERT_GE(blen, 0);
}
TEST(FuzzEncoding, BadDecode1) {
static const int OUT_LEN = 4096;
const char * const bad_encoded = "FAKEBASE64 foo";
char out[OUT_LEN];
memset(out, 0, sizeof(out));
int alen = ceph_unarmor(out, out + OUT_LEN, bad_encoded, bad_encoded + strlen(bad_encoded));
ASSERT_LT(alen, 0);
}
TEST(FuzzEncoding, BadDecode2) {
string str("FAKEBASE64 foo");
bool failed = false;
try {
bufferlist bl;
bl.append(str);
bufferlist cl;
cl.decode_base64(bl);
cl.hexdump(std::cerr);
}
catch (const buffer::error &err) {
failed = true;
}
ASSERT_EQ(failed, true);
}
| 2,671 | 24.941748 | 94 |
cc
|
null |
ceph-main/src/test/bench_journald_logger.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "common/Journald.h"
#include "log/Entry.h"
#include "log/SubsystemMap.h"
using namespace ceph::logging;
int main()
{
SubsystemMap subs;
JournaldLogger journald(&subs);
for (int i = 0; i < 100000; i++) {
MutableEntry entry(0, 0);
entry.get_ostream() << "This is log message " << i << ", which is a little bit looooooooo********ooooooooog and may contains multiple\nlines.";
journald.log_entry(entry);
}
}
| 535 | 24.52381 | 147 |
cc
|
null |
ceph-main/src/test/bench_log.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/types.h"
#include "common/Thread.h"
#include "common/debug.h"
#include "common/Clock.h"
#include "common/config.h"
#include "common/ceph_argparse.h"
#include "global/global_init.h"
#define dout_context g_ceph_context
using namespace std;
struct T : public Thread {
int num;
set<int> myset;
map<int,string> mymap;
explicit T(int n) : num(n) {
myset.insert(123);
myset.insert(456);
mymap[1] = "foo";
mymap[10] = "bar";
}
void *entry() override {
while (num-- > 0)
generic_dout(0) << "this is a typical log line. set "
<< myset << " and map " << mymap << dendl;
return 0;
}
};
void usage(const char *name) {
cout << name << " <threads> <lines>\n"
<< "\t threads: the number of threads for this test.\n"
<< "\t lines: the number of log entries per thread.\n";
}
int main(int argc, const char **argv)
{
if (argc < 3) {
usage(argv[0]);
return EXIT_FAILURE;
}
int threads = atoi(argv[1]);
int num = atoi(argv[2]);
cout << threads << " threads, " << num << " lines per thread" << std::endl;
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_OSD,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
utime_t start = ceph_clock_now();
list<T*> ls;
for (int i=0; i<threads; i++) {
T *t = new T(num);
t->create("t");
ls.push_back(t);
}
for (int i=0; i<threads; i++) {
T *t = ls.front();
ls.pop_front();
t->join();
delete t;
}
utime_t t = ceph_clock_now();
t -= start;
cout << " flushing.. " << t << " so far ..." << std::endl;
g_ceph_context->_log->flush();
utime_t end = ceph_clock_now();
utime_t dur = end - start;
cout << dur << std::endl;
return 0;
}
| 1,880 | 20.62069 | 77 |
cc
|
null |
ceph-main/src/test/bufferlist.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2013 Cloudwatt <[email protected]>
*
* Author: Loic Dachary <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library Public License for more details.
*
*/
#include <limits.h>
#include <errno.h>
#include <sys/uio.h>
#include "include/buffer.h"
#include "include/buffer_raw.h"
#include "include/compat.h"
#include "include/utime.h"
#include "include/coredumpctl.h"
#include "include/encoding.h"
#include "common/buffer_instrumentation.h"
#include "common/environment.h"
#include "common/Clock.h"
#include "common/safe_io.h"
#include "gtest/gtest.h"
#include "stdlib.h"
#include "fcntl.h"
#include "sys/stat.h"
#include "include/crc32c.h"
#include "common/sctp_crc32.h"
#define MAX_TEST 1000000
#define FILENAME "bufferlist"
using namespace std;
static char cmd[128];
using ceph::buffer_instrumentation::instrumented_bptr;
TEST(Buffer, constructors) {
unsigned len = 17;
//
// buffer::create
//
{
bufferptr ptr(buffer::create(len));
EXPECT_EQ(len, ptr.length());
}
//
// buffer::claim_char
//
{
char* str = new char[len];
::memset(str, 'X', len);
bufferptr ptr(buffer::claim_char(len, str));
EXPECT_EQ(len, ptr.length());
EXPECT_EQ(str, ptr.c_str());
EXPECT_EQ(0, ::memcmp(str, ptr.c_str(), len));
delete [] str;
}
//
// buffer::create_static
//
{
char* str = new char[len];
bufferptr ptr(buffer::create_static(len, str));
EXPECT_EQ(len, ptr.length());
EXPECT_EQ(str, ptr.c_str());
delete [] str;
}
//
// buffer::create_malloc
//
{
bufferptr ptr(buffer::create_malloc(len));
EXPECT_EQ(len, ptr.length());
// this doesn't throw on my x86_64 wheezy box --sage
//EXPECT_THROW(buffer::create_malloc((unsigned)ULLONG_MAX), buffer::bad_alloc);
}
//
// buffer::claim_malloc
//
{
char* str = (char*)malloc(len);
::memset(str, 'X', len);
bufferptr ptr(buffer::claim_malloc(len, str));
EXPECT_EQ(len, ptr.length());
EXPECT_EQ(str, ptr.c_str());
EXPECT_EQ(0, ::memcmp(str, ptr.c_str(), len));
}
//
// buffer::copy
//
{
const std::string expected(len, 'X');
bufferptr ptr(buffer::copy(expected.c_str(), expected.size()));
EXPECT_NE(expected.c_str(), ptr.c_str());
EXPECT_EQ(0, ::memcmp(expected.c_str(), ptr.c_str(), len));
}
//
// buffer::create_page_aligned
//
{
bufferptr ptr(buffer::create_page_aligned(len));
::memset(ptr.c_str(), 'X', len);
// doesn't throw on my x86_64 wheezy box --sage
//EXPECT_THROW(buffer::create_page_aligned((unsigned)ULLONG_MAX), buffer::bad_alloc);
#ifndef DARWIN
ASSERT_TRUE(ptr.is_page_aligned());
#endif // DARWIN
}
}
void bench_buffer_alloc(int size, int num)
{
utime_t start = ceph_clock_now();
for (int i=0; i<num; ++i) {
bufferptr p = buffer::create(size);
p.zero();
}
utime_t end = ceph_clock_now();
cout << num << " alloc of size " << size
<< " in " << (end - start) << std::endl;
}
TEST(Buffer, BenchAlloc) {
bench_buffer_alloc(16384, 1000000);
bench_buffer_alloc(4096, 1000000);
bench_buffer_alloc(1024, 1000000);
bench_buffer_alloc(256, 1000000);
bench_buffer_alloc(32, 1000000);
bench_buffer_alloc(4, 1000000);
}
TEST(BufferRaw, ostream) {
bufferptr ptr(1);
std::ostringstream stream;
stream << *static_cast<instrumented_bptr&>(ptr).get_raw();
EXPECT_GT(stream.str().size(), stream.str().find("buffer::raw("));
EXPECT_GT(stream.str().size(), stream.str().find("len 1 nref 1)"));
}
//
// +-----------+ +-----+
// | | | |
// | offset +----------------+ |
// | | | |
// | length +---- | |
// | | \------- | |
// +-----------+ \---+ |
// | ptr | +-----+
// +-----------+ | raw |
// +-----+
//
TEST(BufferPtr, constructors) {
unsigned len = 17;
//
// ptr::ptr()
//
{
buffer::ptr ptr;
EXPECT_FALSE(ptr.have_raw());
EXPECT_EQ((unsigned)0, ptr.offset());
EXPECT_EQ((unsigned)0, ptr.length());
}
//
// ptr::ptr(raw *r)
//
{
bufferptr ptr(buffer::create(len));
EXPECT_TRUE(ptr.have_raw());
EXPECT_EQ((unsigned)0, ptr.offset());
EXPECT_EQ(len, ptr.length());
EXPECT_EQ(ptr.raw_length(), ptr.length());
EXPECT_EQ(1, ptr.raw_nref());
}
//
// ptr::ptr(unsigned l)
//
{
bufferptr ptr(len);
EXPECT_TRUE(ptr.have_raw());
EXPECT_EQ((unsigned)0, ptr.offset());
EXPECT_EQ(len, ptr.length());
EXPECT_EQ(1, ptr.raw_nref());
}
//
// ptr(const char *d, unsigned l)
//
{
const std::string str(len, 'X');
bufferptr ptr(str.c_str(), len);
EXPECT_TRUE(ptr.have_raw());
EXPECT_EQ((unsigned)0, ptr.offset());
EXPECT_EQ(len, ptr.length());
EXPECT_EQ(1, ptr.raw_nref());
EXPECT_EQ(0, ::memcmp(str.c_str(), ptr.c_str(), len));
}
//
// ptr(const ptr& p)
//
{
const std::string str(len, 'X');
bufferptr original(str.c_str(), len);
bufferptr ptr(original);
EXPECT_TRUE(ptr.have_raw());
EXPECT_EQ(static_cast<instrumented_bptr&>(original).get_raw(),
static_cast<instrumented_bptr&>(ptr).get_raw());
EXPECT_EQ(2, ptr.raw_nref());
EXPECT_EQ(0, ::memcmp(original.c_str(), ptr.c_str(), len));
}
//
// ptr(const ptr& p, unsigned o, unsigned l)
//
{
const std::string str(len, 'X');
bufferptr original(str.c_str(), len);
bufferptr ptr(original, 0, 0);
EXPECT_TRUE(ptr.have_raw());
EXPECT_EQ(static_cast<instrumented_bptr&>(original).get_raw(),
static_cast<instrumented_bptr&>(ptr).get_raw());
EXPECT_EQ(2, ptr.raw_nref());
EXPECT_EQ(0, ::memcmp(original.c_str(), ptr.c_str(), len));
PrCtl unset_dumpable;
EXPECT_DEATH(bufferptr(original, 0, original.length() + 1), "");
EXPECT_DEATH(bufferptr(bufferptr(), 0, 0), "");
}
//
// ptr(ptr&& p)
//
{
const std::string str(len, 'X');
bufferptr original(str.c_str(), len);
bufferptr ptr(std::move(original));
EXPECT_TRUE(ptr.have_raw());
EXPECT_FALSE(original.have_raw());
EXPECT_EQ(0, ::memcmp(str.c_str(), ptr.c_str(), len));
EXPECT_EQ(1, ptr.raw_nref());
}
}
TEST(BufferPtr, operator_assign) {
//
// ptr& operator= (const ptr& p)
//
bufferptr ptr(10);
ptr.copy_in(0, 3, "ABC");
char dest[1];
{
bufferptr copy = ptr;
copy.copy_out(1, 1, dest);
ASSERT_EQ('B', dest[0]);
}
//
// ptr& operator= (ptr&& p)
//
bufferptr move = std::move(ptr);
{
move.copy_out(1, 1, dest);
ASSERT_EQ('B', dest[0]);
}
EXPECT_FALSE(ptr.have_raw());
}
TEST(BufferPtr, assignment) {
unsigned len = 17;
//
// override a bufferptr set with the same raw
//
{
bufferptr original(len);
bufferptr same_raw(original);
unsigned offset = 5;
unsigned length = len - offset;
original.set_offset(offset);
original.set_length(length);
same_raw = original;
ASSERT_EQ(2, original.raw_nref());
ASSERT_EQ(static_cast<instrumented_bptr&>(same_raw).get_raw(),
static_cast<instrumented_bptr&>(original).get_raw());
ASSERT_EQ(same_raw.offset(), original.offset());
ASSERT_EQ(same_raw.length(), original.length());
}
//
// self assignment is a noop
//
{
bufferptr original(len);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wself-assign-overloaded"
original = original;
#pragma clang diagnostic pop
ASSERT_EQ(1, original.raw_nref());
ASSERT_EQ((unsigned)0, original.offset());
ASSERT_EQ(len, original.length());
}
//
// a copy points to the same raw
//
{
bufferptr original(len);
unsigned offset = 5;
unsigned length = len - offset;
original.set_offset(offset);
original.set_length(length);
bufferptr ptr;
ptr = original;
ASSERT_EQ(2, original.raw_nref());
ASSERT_EQ(static_cast<instrumented_bptr&>(ptr).get_raw(),
static_cast<instrumented_bptr&>(original).get_raw());
ASSERT_EQ(original.offset(), ptr.offset());
ASSERT_EQ(original.length(), ptr.length());
}
}
TEST(BufferPtr, swap) {
unsigned len = 17;
bufferptr ptr1(len);
::memset(ptr1.c_str(), 'X', len);
unsigned ptr1_offset = 4;
ptr1.set_offset(ptr1_offset);
unsigned ptr1_length = 3;
ptr1.set_length(ptr1_length);
bufferptr ptr2(len);
::memset(ptr2.c_str(), 'Y', len);
unsigned ptr2_offset = 5;
ptr2.set_offset(ptr2_offset);
unsigned ptr2_length = 7;
ptr2.set_length(ptr2_length);
ptr1.swap(ptr2);
EXPECT_EQ(ptr2_length, ptr1.length());
EXPECT_EQ(ptr2_offset, ptr1.offset());
EXPECT_EQ('Y', ptr1[0]);
EXPECT_EQ(ptr1_length, ptr2.length());
EXPECT_EQ(ptr1_offset, ptr2.offset());
EXPECT_EQ('X', ptr2[0]);
}
TEST(BufferPtr, release) {
unsigned len = 17;
bufferptr ptr1(len);
{
bufferptr ptr2(ptr1);
EXPECT_EQ(2, ptr1.raw_nref());
}
EXPECT_EQ(1, ptr1.raw_nref());
}
TEST(BufferPtr, have_raw) {
{
bufferptr ptr;
EXPECT_FALSE(ptr.have_raw());
}
{
bufferptr ptr(1);
EXPECT_TRUE(ptr.have_raw());
}
}
TEST(BufferPtr, is_n_page_sized) {
{
bufferptr ptr(CEPH_PAGE_SIZE);
EXPECT_TRUE(ptr.is_n_page_sized());
}
{
bufferptr ptr(1);
EXPECT_FALSE(ptr.is_n_page_sized());
}
}
TEST(BufferPtr, is_partial) {
bufferptr a;
EXPECT_FALSE(a.is_partial());
bufferptr b(10);
EXPECT_FALSE(b.is_partial());
bufferptr c(b, 1, 9);
EXPECT_TRUE(c.is_partial());
bufferptr d(b, 0, 9);
EXPECT_TRUE(d.is_partial());
}
TEST(BufferPtr, accessors) {
unsigned len = 17;
bufferptr ptr(len);
ptr.c_str()[0] = 'X';
ptr[1] = 'Y';
const bufferptr const_ptr(ptr);
EXPECT_NE((void*)nullptr, (void*)static_cast<instrumented_bptr&>(ptr).get_raw());
EXPECT_EQ('X', ptr.c_str()[0]);
{
bufferptr ptr;
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.c_str(), "");
EXPECT_DEATH(ptr[0], "");
}
EXPECT_EQ('X', const_ptr.c_str()[0]);
{
const bufferptr const_ptr;
PrCtl unset_dumpable;
EXPECT_DEATH(const_ptr.c_str(), "");
EXPECT_DEATH(const_ptr[0], "");
}
EXPECT_EQ(len, const_ptr.length());
EXPECT_EQ((unsigned)0, const_ptr.offset());
EXPECT_EQ((unsigned)0, const_ptr.start());
EXPECT_EQ(len, const_ptr.end());
EXPECT_EQ(len, const_ptr.end());
{
bufferptr ptr(len);
unsigned unused = 1;
ptr.set_length(ptr.length() - unused);
EXPECT_EQ(unused, ptr.unused_tail_length());
}
{
bufferptr ptr;
EXPECT_EQ((unsigned)0, ptr.unused_tail_length());
}
{
PrCtl unset_dumpable;
EXPECT_DEATH(ptr[len], "");
EXPECT_DEATH(const_ptr[len], "");
}
{
const bufferptr const_ptr;
PrCtl unset_dumpable;
EXPECT_DEATH(const_ptr.raw_c_str(), "");
EXPECT_DEATH(const_ptr.raw_length(), "");
EXPECT_DEATH(const_ptr.raw_nref(), "");
}
EXPECT_NE((const char *)NULL, const_ptr.raw_c_str());
EXPECT_EQ(len, const_ptr.raw_length());
EXPECT_EQ(2, const_ptr.raw_nref());
{
bufferptr ptr(len);
unsigned wasted = 1;
ptr.set_length(ptr.length() - wasted * 2);
ptr.set_offset(wasted);
EXPECT_EQ(wasted * 2, ptr.wasted());
}
}
TEST(BufferPtr, cmp) {
bufferptr empty;
bufferptr a("A", 1);
bufferptr ab("AB", 2);
bufferptr af("AF", 2);
bufferptr acc("ACC", 3);
EXPECT_GE(-1, empty.cmp(a));
EXPECT_LE(1, a.cmp(empty));
EXPECT_GE(-1, a.cmp(ab));
EXPECT_LE(1, ab.cmp(a));
EXPECT_EQ(0, ab.cmp(ab));
EXPECT_GE(-1, ab.cmp(af));
EXPECT_LE(1, af.cmp(ab));
EXPECT_GE(-1, acc.cmp(af));
EXPECT_LE(1, af.cmp(acc));
}
TEST(BufferPtr, is_zero) {
char str[2] = { '\0', 'X' };
{
const bufferptr ptr(buffer::create_static(2, str));
EXPECT_FALSE(ptr.is_zero());
}
{
const bufferptr ptr(buffer::create_static(1, str));
EXPECT_TRUE(ptr.is_zero());
}
}
TEST(BufferPtr, copy_out) {
{
const bufferptr ptr;
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.copy_out((unsigned)0, (unsigned)0, NULL), "");
}
{
char in[] = "ABC";
const bufferptr ptr(buffer::create_static(strlen(in), in));
EXPECT_THROW(ptr.copy_out((unsigned)0, strlen(in) + 1, NULL), buffer::end_of_buffer);
EXPECT_THROW(ptr.copy_out(strlen(in) + 1, (unsigned)0, NULL), buffer::end_of_buffer);
char out[1] = { 'X' };
ptr.copy_out((unsigned)1, (unsigned)1, out);
EXPECT_EQ('B', out[0]);
}
}
TEST(BufferPtr, copy_out_bench) {
for (int s=1; s<=8; s*=2) {
utime_t start = ceph_clock_now();
int buflen = 1048576;
int count = 1000;
uint64_t v;
for (int i=0; i<count; ++i) {
bufferptr bp(buflen);
for (int64_t j=0; j<buflen; j += s) {
bp.copy_out(j, s, (char *)&v);
}
}
utime_t end = ceph_clock_now();
cout << count << " fills of buffer len " << buflen
<< " with " << s << " byte copy_out in "
<< (end - start) << std::endl;
}
}
TEST(BufferPtr, copy_in) {
{
bufferptr ptr;
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.copy_in((unsigned)0, (unsigned)0, NULL), "");
}
{
char in[] = "ABCD";
bufferptr ptr(2);
{
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.copy_in((unsigned)0, strlen(in) + 1, NULL), "");
EXPECT_DEATH(ptr.copy_in(strlen(in) + 1, (unsigned)0, NULL), "");
}
ptr.copy_in((unsigned)0, (unsigned)2, in);
EXPECT_EQ(in[0], ptr[0]);
EXPECT_EQ(in[1], ptr[1]);
}
}
TEST(BufferPtr, copy_in_bench) {
for (int s=1; s<=8; s*=2) {
utime_t start = ceph_clock_now();
int buflen = 1048576;
int count = 1000;
for (int i=0; i<count; ++i) {
bufferptr bp(buflen);
for (int64_t j=0; j<buflen; j += s) {
bp.copy_in(j, s, (char *)&j, false);
}
}
utime_t end = ceph_clock_now();
cout << count << " fills of buffer len " << buflen
<< " with " << s << " byte copy_in in "
<< (end - start) << std::endl;
}
}
TEST(BufferPtr, append) {
{
bufferptr ptr;
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.append('A'), "");
EXPECT_DEATH(ptr.append("B", (unsigned)1), "");
}
{
bufferptr ptr(2);
{
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.append('A'), "");
EXPECT_DEATH(ptr.append("B", (unsigned)1), "");
}
ptr.set_length(0);
ptr.append('A');
EXPECT_EQ((unsigned)1, ptr.length());
EXPECT_EQ('A', ptr[0]);
ptr.append("B", (unsigned)1);
EXPECT_EQ((unsigned)2, ptr.length());
EXPECT_EQ('B', ptr[1]);
}
}
TEST(BufferPtr, append_bench) {
char src[1048576];
memset(src, 0, sizeof(src));
for (int s=4; s<=16384; s*=4) {
utime_t start = ceph_clock_now();
int buflen = 1048576;
int count = 4000;
for (int i=0; i<count; ++i) {
bufferptr bp(buflen);
bp.set_length(0);
for (int64_t j=0; j<buflen; j += s) {
bp.append(src + j, s);
}
}
utime_t end = ceph_clock_now();
cout << count << " fills of buffer len " << buflen
<< " with " << s << " byte appends in "
<< (end - start) << std::endl;
}
}
TEST(BufferPtr, zero) {
char str[] = "XXXX";
bufferptr ptr(buffer::create_static(strlen(str), str));
{
PrCtl unset_dumpable;
EXPECT_DEATH(ptr.zero(ptr.length() + 1, 0), "");
}
ptr.zero(1, 1);
EXPECT_EQ('X', ptr[0]);
EXPECT_EQ('\0', ptr[1]);
EXPECT_EQ('X', ptr[2]);
ptr.zero();
EXPECT_EQ('\0', ptr[0]);
}
TEST(BufferPtr, ostream) {
{
bufferptr ptr;
std::ostringstream stream;
stream << ptr;
EXPECT_GT(stream.str().size(), stream.str().find("buffer:ptr(0~0 no raw"));
}
{
char str[] = "XXXX";
bufferptr ptr(buffer::create_static(strlen(str), str));
std::ostringstream stream;
stream << ptr;
EXPECT_GT(stream.str().size(), stream.str().find("len 4 nref 1)"));
}
}
//
// +---------+
// | +-----+ |
// list ptr | | | |
// +----------+ +-----+ | | | |
// | append_ >-------> >--------------------> | |
// | buffer | +-----+ | | | |
// +----------+ ptr | | | |
// | _len | list +-----+ | | | |
// +----------+ +------+ ,--->+ >-----> | |
// | _buffers >----> >----- +-----+ | +-----+ |
// +----------+ +----^-+ \ ptr | raw |
// | last_p | / `-->+-----+ | +-----+ |
// +--------+-+ / + >-----> | |
// | ,- ,--->+-----+ | | | |
// | / ,--- | | | |
// | / ,--- | | | |
// +-v--+-^--+--^+-------+ | | | |
// | bl | ls | p | p_off >--------------->| | |
// +----+----+-----+-----+ | +-----+ |
// | | off >------------->| raw |
// +---------------+-----+ | |
// iterator +---------+
//
TEST(BufferListIterator, constructors) {
//
// iterator()
//
{
buffer::list::iterator i;
EXPECT_EQ((unsigned)0, i.get_off());
}
//
// iterator(list *l, unsigned o=0)
//
{
bufferlist bl;
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl);
EXPECT_EQ((unsigned)0, i.get_off());
EXPECT_EQ('A', *i);
}
{
bufferlist::iterator i(&bl, 1);
EXPECT_EQ('B', *i);
EXPECT_EQ((unsigned)2, i.get_remaining());
}
}
//
// iterator(list *l, unsigned o, std::list<ptr>::iterator ip, unsigned po)
// not tested because of http://tracker.ceph.com/issues/4101
//
// iterator(const iterator& other)
//
{
bufferlist bl;
bl.append("ABC", 3);
bufferlist::iterator i(&bl, 1);
bufferlist::iterator j(i);
EXPECT_EQ(*i, *j);
++j;
EXPECT_NE(*i, *j);
EXPECT_EQ('B', *i);
EXPECT_EQ('C', *j);
bl.c_str()[1] = 'X';
}
//
// const_iterator(const iterator& other)
//
{
bufferlist bl;
bl.append("ABC", 3);
bufferlist::iterator i(&bl);
bufferlist::const_iterator ci(i);
EXPECT_EQ(0u, ci.get_off());
EXPECT_EQ('A', *ci);
}
}
TEST(BufferListIterator, empty_create_append_copy) {
bufferlist bl, bl2, bl3, out;
bl2.append("bar");
bl.swap(bl2);
bl2.append("xxx");
bl.append(bl2);
bl.rebuild();
bl.begin().copy(6, out);
ASSERT_TRUE(out.contents_equal(bl));
}
TEST(BufferListIterator, operator_assign) {
bufferlist bl;
bl.append("ABC", 3);
bufferlist::iterator i(&bl, 1);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wself-assign-overloaded"
i = i;
#pragma clang diagnostic pop
EXPECT_EQ('B', *i);
bufferlist::iterator j;
j = i;
EXPECT_EQ('B', *j);
}
TEST(BufferListIterator, get_off) {
bufferlist bl;
bl.append("ABC", 3);
bufferlist::iterator i(&bl, 1);
EXPECT_EQ((unsigned)1, i.get_off());
}
TEST(BufferListIterator, get_remaining) {
bufferlist bl;
bl.append("ABC", 3);
bufferlist::iterator i(&bl, 1);
EXPECT_EQ((unsigned)2, i.get_remaining());
}
TEST(BufferListIterator, end) {
bufferlist bl;
{
bufferlist::iterator i(&bl);
EXPECT_TRUE(i.end());
}
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl);
EXPECT_FALSE(i.end());
}
}
static void bench_bufferlistiter_deref(const size_t step,
const size_t bufsize,
const size_t bufnum) {
const std::string buf(bufsize, 'a');
ceph::bufferlist bl;
for (size_t i = 0; i < bufnum; i++) {
bl.append(ceph::bufferptr(buf.c_str(), buf.size()));
}
utime_t start = ceph_clock_now();
bufferlist::iterator iter = bl.begin();
while (iter != bl.end()) {
iter += step;
}
utime_t end = ceph_clock_now();
cout << bufsize * bufnum << " derefs over bl with " << bufnum
<< " buffers, each " << bufsize << " bytes long"
<< " in " << (end - start) << std::endl;
}
TEST(BufferListIterator, BenchDeref) {
bench_bufferlistiter_deref(1, 1, 4096000);
bench_bufferlistiter_deref(1, 10, 409600);
bench_bufferlistiter_deref(1, 100, 40960);
bench_bufferlistiter_deref(1, 1000, 4096);
bench_bufferlistiter_deref(4, 1, 1024000);
bench_bufferlistiter_deref(4, 10, 102400);
bench_bufferlistiter_deref(4, 100, 10240);
bench_bufferlistiter_deref(4, 1000, 1024);
}
TEST(BufferListIterator, advance) {
bufferlist bl;
const std::string one("ABC");
bl.append(bufferptr(one.c_str(), one.size()));
const std::string two("DEF");
bl.append(bufferptr(two.c_str(), two.size()));
{
bufferlist::iterator i(&bl);
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
}
{
bufferlist::iterator i(&bl);
EXPECT_EQ('A', *i);
i += 1u;
EXPECT_EQ('B', *i);
i += 3u;
EXPECT_EQ('E', *i);
}
}
TEST(BufferListIterator, iterate_with_empties) {
ceph::bufferlist bl;
EXPECT_EQ(bl.get_num_buffers(), 0u);
bl.push_back(ceph::buffer::create(0));
EXPECT_EQ(bl.length(), 0u);
EXPECT_EQ(bl.get_num_buffers(), 1u);
encode(int64_t(42), bl);
EXPECT_EQ(bl.get_num_buffers(), 2u);
bl.push_back(ceph::buffer::create(0));
EXPECT_EQ(bl.get_num_buffers(), 3u);
// append bufferlist with single, 0-sized ptr inside
{
ceph::bufferlist bl_with_empty_ptr;
bl_with_empty_ptr.push_back(ceph::buffer::create(0));
EXPECT_EQ(bl_with_empty_ptr.length(), 0u);
EXPECT_EQ(bl_with_empty_ptr.get_num_buffers(), 1u);
bl.append(bl_with_empty_ptr);
}
encode(int64_t(24), bl);
EXPECT_EQ(bl.get_num_buffers(), 5u);
auto i = bl.cbegin();
int64_t val;
decode(val, i);
EXPECT_EQ(val, 42l);
decode(val, i);
EXPECT_EQ(val, 24l);
val = 0;
i.seek(sizeof(val));
decode(val, i);
EXPECT_EQ(val, 24l);
EXPECT_TRUE(i == bl.end());
i.seek(0);
decode(val, i);
EXPECT_EQ(val, 42);
EXPECT_FALSE(i == bl.end());
}
TEST(BufferListIterator, get_ptr_and_advance)
{
bufferptr a("one", 3);
bufferptr b("two", 3);
bufferptr c("three", 5);
bufferlist bl;
bl.append(a);
bl.append(b);
bl.append(c);
const char *ptr;
bufferlist::iterator p = bl.begin();
ASSERT_EQ(3u, p.get_ptr_and_advance(11u, &ptr));
ASSERT_EQ(bl.length() - 3u, p.get_remaining());
ASSERT_EQ(0, memcmp(ptr, "one", 3));
ASSERT_EQ(2u, p.get_ptr_and_advance(2u, &ptr));
ASSERT_EQ(0, memcmp(ptr, "tw", 2));
ASSERT_EQ(1u, p.get_ptr_and_advance(4u, &ptr));
ASSERT_EQ(0, memcmp(ptr, "o", 1));
ASSERT_EQ(5u, p.get_ptr_and_advance(5u, &ptr));
ASSERT_EQ(0, memcmp(ptr, "three", 5));
ASSERT_EQ(0u, p.get_remaining());
}
TEST(BufferListIterator, iterator_crc32c) {
bufferlist bl1;
bufferlist bl2;
bufferlist bl3;
string s1(100, 'a');
string s2(50, 'b');
string s3(7, 'c');
string s;
bl1.append(s1);
bl1.append(s2);
bl1.append(s3);
s = s1 + s2 + s3;
bl2.append(s);
bufferlist::iterator it = bl2.begin();
ASSERT_EQ(bl1.crc32c(0), it.crc32c(it.get_remaining(), 0));
ASSERT_EQ(0u, it.get_remaining());
it = bl1.begin();
ASSERT_EQ(bl2.crc32c(0), it.crc32c(it.get_remaining(), 0));
bl3.append(s.substr(98, 55));
it = bl1.begin();
it += 98u;
ASSERT_EQ(bl3.crc32c(0), it.crc32c(55, 0));
ASSERT_EQ(4u, it.get_remaining());
bl3.clear();
bl3.append(s.substr(98 + 55));
it = bl1.begin();
it += 98u + 55u;
ASSERT_EQ(bl3.crc32c(0), it.crc32c(10, 0));
ASSERT_EQ(0u, it.get_remaining());
}
TEST(BufferListIterator, seek) {
bufferlist bl;
bl.append("ABC", 3);
bufferlist::iterator i(&bl, 1);
EXPECT_EQ('B', *i);
i.seek(2);
EXPECT_EQ('C', *i);
}
TEST(BufferListIterator, operator_star) {
bufferlist bl;
{
bufferlist::iterator i(&bl);
EXPECT_THROW(*i, buffer::end_of_buffer);
}
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl);
EXPECT_EQ('A', *i);
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
EXPECT_THROW(*i, buffer::end_of_buffer);
}
}
TEST(BufferListIterator, operator_equal) {
bufferlist bl;
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl);
bufferlist::iterator j(&bl);
EXPECT_EQ(i, j);
}
{
bufferlist::const_iterator ci = bl.begin();
bufferlist::iterator i = bl.begin();
EXPECT_EQ(i, ci);
EXPECT_EQ(ci, i);
}
}
TEST(BufferListIterator, operator_nequal) {
bufferlist bl;
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl);
bufferlist::iterator j(&bl);
EXPECT_NE(++i, j);
}
{
bufferlist::const_iterator ci = bl.begin();
bufferlist::const_iterator cj = bl.begin();
++ci;
EXPECT_NE(ci, cj);
bufferlist::iterator i = bl.begin();
EXPECT_NE(i, ci);
EXPECT_NE(ci, i);
}
{
// tests begin(), end(), operator++() also
string s("ABC");
int i = 0;
for (auto c : bl) {
EXPECT_EQ(s[i++], c);
}
}
}
TEST(BufferListIterator, operator_plus_plus) {
bufferlist bl;
{
bufferlist::iterator i(&bl);
EXPECT_THROW(++i, buffer::end_of_buffer);
}
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl);
++i;
EXPECT_EQ('B', *i);
}
}
TEST(BufferListIterator, get_current_ptr) {
bufferlist bl;
{
bufferlist::iterator i(&bl);
EXPECT_THROW(++i, buffer::end_of_buffer);
}
bl.append("ABC", 3);
{
bufferlist::iterator i(&bl, 1);
const buffer::ptr ptr = i.get_current_ptr();
EXPECT_EQ('B', ptr[0]);
EXPECT_EQ((unsigned)1, ptr.offset());
EXPECT_EQ((unsigned)2, ptr.length());
}
}
TEST(BufferListIterator, copy) {
bufferlist bl;
const char *expected = "ABC";
bl.append(expected, 3);
//
// void copy(unsigned len, char *dest);
//
{
char* copy = (char*)malloc(3);
::memset(copy, 'X', 3);
bufferlist::iterator i(&bl);
//
// demonstrates that it seeks back to offset if p == ls->end()
//
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
i.copy(2, copy);
EXPECT_EQ(0, ::memcmp(copy, expected, 2));
EXPECT_EQ('X', copy[2]);
i.seek(0);
i.copy(3, copy);
EXPECT_EQ(0, ::memcmp(copy, expected, 3));
free(copy);
}
//
// void copy(unsigned len, char *dest) via begin(size_t offset)
//
{
bufferlist bl;
EXPECT_THROW(bl.begin((unsigned)100).copy((unsigned)100, (char*)0), buffer::end_of_buffer);
const char *expected = "ABC";
bl.append(expected);
char *dest = new char[2];
bl.begin(1).copy(2, dest);
EXPECT_EQ(0, ::memcmp(expected + 1, dest, 2));
delete [] dest;
}
//
// void buffer::list::iterator::copy_deep(unsigned len, ptr &dest)
//
{
bufferptr ptr;
bufferlist::iterator i(&bl);
i.copy_deep(2, ptr);
EXPECT_EQ((unsigned)2, ptr.length());
EXPECT_EQ('A', ptr[0]);
EXPECT_EQ('B', ptr[1]);
}
//
// void buffer::list::iterator::copy_shallow(unsigned len, ptr &dest)
//
{
bufferptr ptr;
bufferlist::iterator i(&bl);
i.copy_shallow(2, ptr);
EXPECT_EQ((unsigned)2, ptr.length());
EXPECT_EQ('A', ptr[0]);
EXPECT_EQ('B', ptr[1]);
}
//
// void buffer::list::iterator::copy(unsigned len, list &dest)
//
{
bufferlist copy;
bufferlist::iterator i(&bl);
//
// demonstrates that it seeks back to offset if p == ls->end()
//
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
i.copy(2, copy);
EXPECT_EQ(0, ::memcmp(copy.c_str(), expected, 2));
i.seek(0);
i.copy(3, copy);
EXPECT_EQ('A', copy[0]);
EXPECT_EQ('B', copy[1]);
EXPECT_EQ('A', copy[2]);
EXPECT_EQ('B', copy[3]);
EXPECT_EQ('C', copy[4]);
EXPECT_EQ((unsigned)(2 + 3), copy.length());
}
//
// void buffer::list::iterator::copy(unsigned len, list &dest) via begin(size_t offset)
//
{
bufferlist bl;
bufferlist dest;
EXPECT_THROW(bl.begin((unsigned)100).copy((unsigned)100, dest), buffer::end_of_buffer);
const char *expected = "ABC";
bl.append(expected);
bl.begin(1).copy(2, dest);
EXPECT_EQ(0, ::memcmp(expected + 1, dest.c_str(), 2));
}
//
// void buffer::list::iterator::copy_all(list &dest)
//
{
bufferlist copy;
bufferlist::iterator i(&bl);
//
// demonstrates that it seeks back to offset if p == ls->end()
//
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
i.copy_all(copy);
EXPECT_EQ('A', copy[0]);
EXPECT_EQ('B', copy[1]);
EXPECT_EQ('C', copy[2]);
EXPECT_EQ((unsigned)3, copy.length());
}
//
// void copy(unsigned len, std::string &dest)
//
{
std::string copy;
bufferlist::iterator i(&bl);
//
// demonstrates that it seeks back to offset if p == ls->end()
//
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
i.copy(2, copy);
EXPECT_EQ(0, ::memcmp(copy.c_str(), expected, 2));
i.seek(0);
i.copy(3, copy);
EXPECT_EQ('A', copy[0]);
EXPECT_EQ('B', copy[1]);
EXPECT_EQ('A', copy[2]);
EXPECT_EQ('B', copy[3]);
EXPECT_EQ('C', copy[4]);
EXPECT_EQ((unsigned)(2 + 3), copy.length());
}
//
// void copy(unsigned len, std::string &dest) via begin(size_t offset)
//
{
bufferlist bl;
std::string dest;
EXPECT_THROW(bl.begin((unsigned)100).copy((unsigned)100, dest), buffer::end_of_buffer);
const char *expected = "ABC";
bl.append(expected);
bl.begin(1).copy(2, dest);
EXPECT_EQ(0, ::memcmp(expected + 1, dest.c_str(), 2));
}
}
TEST(BufferListIterator, copy_in) {
bufferlist bl;
const char *existing = "XXX";
bl.append(existing, 3);
//
// void buffer::list::iterator::copy_in(unsigned len, const char *src)
//
{
bufferlist::iterator i(&bl);
//
// demonstrates that it seeks back to offset if p == ls->end()
//
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
const char *expected = "ABC";
i.copy_in(3, expected);
EXPECT_EQ(0, ::memcmp(bl.c_str(), expected, 3));
EXPECT_EQ('A', bl[0]);
EXPECT_EQ('B', bl[1]);
EXPECT_EQ('C', bl[2]);
EXPECT_EQ((unsigned)3, bl.length());
}
//
// void copy_in(unsigned len, const char *src) via begin(size_t offset)
//
{
bufferlist bl;
bl.append("XXX");
EXPECT_THROW(bl.begin((unsigned)100).copy_in((unsigned)100, (char*)0), buffer::end_of_buffer);
bl.begin(1).copy_in(2, "AB");
EXPECT_EQ(0, ::memcmp("XAB", bl.c_str(), 3));
}
//
// void buffer::list::iterator::copy_in(unsigned len, const list& otherl)
//
{
bufferlist::iterator i(&bl);
//
// demonstrates that it seeks back to offset if p == ls->end()
//
EXPECT_THROW(i += 200u, buffer::end_of_buffer);
bufferlist expected;
expected.append("ABC", 3);
i.copy_in(3, expected);
EXPECT_EQ(0, ::memcmp(bl.c_str(), expected.c_str(), 3));
EXPECT_EQ('A', bl[0]);
EXPECT_EQ('B', bl[1]);
EXPECT_EQ('C', bl[2]);
EXPECT_EQ((unsigned)3, bl.length());
}
//
// void copy_in(unsigned len, const list& src) via begin(size_t offset)
//
{
bufferlist bl;
bl.append("XXX");
bufferlist src;
src.append("ABC");
EXPECT_THROW(bl.begin((unsigned)100).copy_in((unsigned)100, src), buffer::end_of_buffer);
bl.begin(1).copy_in(2, src);
EXPECT_EQ(0, ::memcmp("XAB", bl.c_str(), 3));
}
}
// iterator& buffer::list::const_iterator::operator++()
TEST(BufferListConstIterator, operator_plus_plus) {
bufferlist bl;
{
bufferlist::const_iterator i(&bl);
EXPECT_THROW(++i, buffer::end_of_buffer);
}
bl.append("ABC", 3);
{
const bufferlist const_bl(bl);
bufferlist::const_iterator i(const_bl.begin());
++i;
EXPECT_EQ('B', *i);
}
}
TEST(BufferList, constructors) {
//
// list()
//
{
bufferlist bl;
ASSERT_EQ((unsigned)0, bl.length());
}
//
// list(unsigned prealloc)
//
{
bufferlist bl(1);
ASSERT_EQ((unsigned)0, bl.length());
bl.append('A');
ASSERT_EQ('A', bl[0]);
}
//
// list(const list& other)
//
{
bufferlist bl(1);
bl.append('A');
ASSERT_EQ('A', bl[0]);
bufferlist copy(bl);
ASSERT_EQ('A', copy[0]);
}
//
// list(list&& other)
//
{
bufferlist bl(1);
bl.append('A');
bufferlist copy = std::move(bl);
ASSERT_EQ(0U, bl.length());
ASSERT_EQ(1U, copy.length());
ASSERT_EQ('A', copy[0]);
}
}
TEST(BufferList, append_after_move) {
bufferlist bl(6);
bl.append("ABC", 3);
EXPECT_EQ(1, bl.get_num_buffers());
bufferlist moved_to_bl(std::move(bl));
moved_to_bl.append("123", 3);
// it's expected that the list(list&&) ctor will preserve the _carriage
EXPECT_EQ(1, moved_to_bl.get_num_buffers());
EXPECT_EQ(0, ::memcmp("ABC123", moved_to_bl.c_str(), 6));
}
void bench_bufferlist_alloc(int size, int num, int per)
{
utime_t start = ceph_clock_now();
for (int i=0; i<num; ++i) {
bufferlist bl;
for (int j=0; j<per; ++j)
bl.push_back(buffer::ptr_node::create(buffer::create(size)));
}
utime_t end = ceph_clock_now();
cout << num << " alloc of size " << size
<< " in " << (end - start) << std::endl;
}
TEST(BufferList, BenchAlloc) {
bench_bufferlist_alloc(32768, 100000, 16);
bench_bufferlist_alloc(25000, 100000, 16);
bench_bufferlist_alloc(16384, 100000, 16);
bench_bufferlist_alloc(10000, 100000, 16);
bench_bufferlist_alloc(8192, 100000, 16);
bench_bufferlist_alloc(6000, 100000, 16);
bench_bufferlist_alloc(4096, 100000, 16);
bench_bufferlist_alloc(1024, 100000, 16);
bench_bufferlist_alloc(256, 100000, 16);
bench_bufferlist_alloc(32, 100000, 16);
bench_bufferlist_alloc(4, 100000, 16);
}
/*
* append_bench tests now have multiple variants:
*
* Version 1 tests allocate a single bufferlist during loop iteration.
* Ultimately very little memory is utilized since the bufferlist immediately
* drops out of scope. This was the original variant of these tests but showed
* unexpected performance characteristics that appears to be tied to tcmalloc
* and/or kernel behavior depending on the bufferlist size and step size.
*
* Version 2 tests allocate a configurable number of bufferlists that are
* replaced round-robin during loop iteration. Version 2 tests are designed
* to better mimic performance when multiple bufferlists are in memory at the
* same time. During testing this showed more consistent and seemingly
* accurate behavior across bufferlist and step sizes.
*/
TEST(BufferList, append_bench_with_size_hint) {
std::array<char, 1048576> src = { 0, };
for (size_t step = 4; step <= 16384; step *= 4) {
const utime_t start = ceph_clock_now();
constexpr size_t rounds = 4000;
for (size_t r = 0; r < rounds; ++r) {
ceph::bufferlist bl(std::size(src));
for (auto iter = std::begin(src);
iter != std::end(src);
iter = std::next(iter, step)) {
bl.append(&*iter, step);
}
}
cout << rounds << " fills of buffer len " << src.size()
<< " with " << step << " byte appends in "
<< (ceph_clock_now() - start) << std::endl;
}
}
TEST(BufferList, append_bench_with_size_hint2) {
std::array<char, 1048576> src = { 0, };
constexpr size_t rounds = 4000;
constexpr int conc_bl = 400;
std::vector<ceph::bufferlist*> bls(conc_bl);
for (int i = 0; i < conc_bl; i++) {
bls[i] = new ceph::bufferlist;
}
for (size_t step = 4; step <= 16384; step *= 4) {
const utime_t start = ceph_clock_now();
for (size_t r = 0; r < rounds; ++r) {
delete bls[r % conc_bl];
bls[r % conc_bl] = new ceph::bufferlist(std::size(src));
for (auto iter = std::begin(src);
iter != std::end(src);
iter = std::next(iter, step)) {
bls[r % conc_bl]->append(&*iter, step);
}
}
cout << rounds << " fills of buffer len " << src.size()
<< " with " << step << " byte appends in "
<< (ceph_clock_now() - start) << std::endl;
}
for (int i = 0; i < conc_bl; i++) {
delete bls[i];
}
}
TEST(BufferList, append_bench) {
std::array<char, 1048576> src = { 0, };
for (size_t step = 4; step <= 16384; step *= 4) {
const utime_t start = ceph_clock_now();
constexpr size_t rounds = 4000;
for (size_t r = 0; r < rounds; ++r) {
ceph::bufferlist bl;
for (auto iter = std::begin(src);
iter != std::end(src);
iter = std::next(iter, step)) {
bl.append(&*iter, step);
}
}
cout << rounds << " fills of buffer len " << src.size()
<< " with " << step << " byte appends in "
<< (ceph_clock_now() - start) << std::endl;
}
}
TEST(BufferList, append_bench2) {
std::array<char, 1048576> src = { 0, };
constexpr size_t rounds = 4000;
constexpr int conc_bl = 400;
std::vector<ceph::bufferlist*> bls(conc_bl);
for (int i = 0; i < conc_bl; i++) {
bls[i] = new ceph::bufferlist;
}
for (size_t step = 4; step <= 16384; step *= 4) {
const utime_t start = ceph_clock_now();
for (size_t r = 0; r < rounds; ++r) {
delete bls[r % conc_bl];
bls[r % conc_bl] = new ceph::bufferlist;
for (auto iter = std::begin(src);
iter != std::end(src);
iter = std::next(iter, step)) {
bls[r % conc_bl]->append(&*iter, step);
}
}
cout << rounds << " fills of buffer len " << src.size()
<< " with " << step << " byte appends in "
<< (ceph_clock_now() - start) << std::endl;
}
for (int i = 0; i < conc_bl; i++) {
delete bls[i];
}
}
TEST(BufferList, append_hole_bench) {
constexpr size_t targeted_bl_size = 1048576;
for (size_t step = 512; step <= 65536; step *= 2) {
const utime_t start = ceph_clock_now();
constexpr size_t rounds = 80000;
for (size_t r = 0; r < rounds; ++r) {
ceph::bufferlist bl;
while (bl.length() < targeted_bl_size) {
bl.append_hole(step);
}
}
cout << rounds << " fills of buffer len " << targeted_bl_size
<< " with " << step << " byte long append_hole in "
<< (ceph_clock_now() - start) << std::endl;
}
}
TEST(BufferList, append_hole_bench2) {
constexpr size_t targeted_bl_size = 1048576;
constexpr size_t rounds = 80000;
constexpr int conc_bl = 400;
std::vector<ceph::bufferlist*> bls(conc_bl);
for (int i = 0; i < conc_bl; i++) {
bls[i] = new ceph::bufferlist;
}
for (size_t step = 512; step <= 65536; step *= 2) {
const utime_t start = ceph_clock_now();
for (size_t r = 0; r < rounds; ++r) {
delete bls[r % conc_bl];
bls[r % conc_bl] = new ceph::bufferlist;
while (bls[r % conc_bl]->length() < targeted_bl_size) {
bls[r % conc_bl]->append_hole(step);
}
}
cout << rounds << " fills of buffer len " << targeted_bl_size
<< " with " << step << " byte long append_hole in "
<< (ceph_clock_now() - start) << std::endl;
}
for (int i = 0; i < conc_bl; i++) {
delete bls[i];
}
}
TEST(BufferList, operator_assign_rvalue) {
bufferlist from;
{
bufferptr ptr(2);
from.append(ptr);
}
bufferlist to;
{
bufferptr ptr(4);
to.append(ptr);
}
EXPECT_EQ((unsigned)4, to.length());
EXPECT_EQ((unsigned)1, to.get_num_buffers());
to = std::move(from);
EXPECT_EQ((unsigned)2, to.length());
EXPECT_EQ((unsigned)1, to.get_num_buffers());
EXPECT_EQ((unsigned)0, from.get_num_buffers());
EXPECT_EQ((unsigned)0, from.length());
}
TEST(BufferList, operator_equal) {
//
// list& operator= (const list& other)
//
bufferlist bl;
bl.append("ABC", 3);
{
std::string dest;
bl.begin(1).copy(1, dest);
ASSERT_EQ('B', dest[0]);
}
{
bufferlist copy = bl;
std::string dest;
copy.begin(1).copy(1, dest);
ASSERT_EQ('B', dest[0]);
}
//
// list& operator= (list&& other)
//
bufferlist move;
move = std::move(bl);
{
std::string dest;
move.begin(1).copy(1, dest);
ASSERT_EQ('B', dest[0]);
}
EXPECT_TRUE(move.length());
EXPECT_TRUE(!bl.length());
}
TEST(BufferList, buffers) {
bufferlist bl;
ASSERT_EQ((unsigned)0, bl.get_num_buffers());
bl.append('A');
ASSERT_EQ((unsigned)1, bl.get_num_buffers());
}
TEST(BufferList, to_str) {
{
bufferlist bl;
bl.append("foo");
ASSERT_EQ(bl.to_str(), string("foo"));
}
{
bufferptr a("foobarbaz", 9);
bufferptr b("123456789", 9);
bufferptr c("ABCDEFGHI", 9);
bufferlist bl;
bl.append(a);
bl.append(b);
bl.append(c);
ASSERT_EQ(bl.to_str(), string("foobarbaz123456789ABCDEFGHI"));
}
}
TEST(BufferList, swap) {
bufferlist b1;
b1.append('A');
bufferlist b2;
b2.append('B');
b1.swap(b2);
std::string s1;
b1.begin().copy(1, s1);
ASSERT_EQ('B', s1[0]);
std::string s2;
b2.begin().copy(1, s2);
ASSERT_EQ('A', s2[0]);
}
TEST(BufferList, length) {
bufferlist bl;
ASSERT_EQ((unsigned)0, bl.length());
bl.append('A');
ASSERT_EQ((unsigned)1, bl.length());
}
TEST(BufferList, contents_equal) {
//
// A BB
// AB B
//
bufferlist bl1;
bl1.append("A");
bl1.append("BB");
bufferlist bl2;
ASSERT_FALSE(bl1.contents_equal(bl2)); // different length
bl2.append("AB");
bl2.append("B");
ASSERT_TRUE(bl1.contents_equal(bl2)); // same length same content
//
// ABC
//
bufferlist bl3;
bl3.append("ABC");
ASSERT_FALSE(bl1.contents_equal(bl3)); // same length different content
}
TEST(BufferList, is_aligned) {
const int SIMD_ALIGN = 32;
{
bufferlist bl;
EXPECT_TRUE(bl.is_aligned(SIMD_ALIGN));
}
{
bufferlist bl;
bufferptr ptr(buffer::create_aligned(2, SIMD_ALIGN));
ptr.set_offset(1);
ptr.set_length(1);
bl.append(ptr);
EXPECT_FALSE(bl.is_aligned(SIMD_ALIGN));
bl.rebuild_aligned(SIMD_ALIGN);
EXPECT_TRUE(bl.is_aligned(SIMD_ALIGN));
}
{
bufferlist bl;
bufferptr ptr(buffer::create_aligned(SIMD_ALIGN + 1, SIMD_ALIGN));
ptr.set_offset(1);
ptr.set_length(SIMD_ALIGN);
bl.append(ptr);
EXPECT_FALSE(bl.is_aligned(SIMD_ALIGN));
bl.rebuild_aligned(SIMD_ALIGN);
EXPECT_TRUE(bl.is_aligned(SIMD_ALIGN));
}
}
TEST(BufferList, is_n_align_sized) {
const int SIMD_ALIGN = 32;
{
bufferlist bl;
EXPECT_TRUE(bl.is_n_align_sized(SIMD_ALIGN));
}
{
bufferlist bl;
bl.append_zero(1);
EXPECT_FALSE(bl.is_n_align_sized(SIMD_ALIGN));
}
{
bufferlist bl;
bl.append_zero(SIMD_ALIGN);
EXPECT_TRUE(bl.is_n_align_sized(SIMD_ALIGN));
}
}
TEST(BufferList, is_page_aligned) {
{
bufferlist bl;
EXPECT_TRUE(bl.is_page_aligned());
}
{
bufferlist bl;
bufferptr ptr(buffer::create_page_aligned(2));
ptr.set_offset(1);
ptr.set_length(1);
bl.append(ptr);
EXPECT_FALSE(bl.is_page_aligned());
bl.rebuild_page_aligned();
EXPECT_TRUE(bl.is_page_aligned());
}
{
bufferlist bl;
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE + 1));
ptr.set_offset(1);
ptr.set_length(CEPH_PAGE_SIZE);
bl.append(ptr);
EXPECT_FALSE(bl.is_page_aligned());
bl.rebuild_page_aligned();
EXPECT_TRUE(bl.is_page_aligned());
}
}
TEST(BufferList, is_n_page_sized) {
{
bufferlist bl;
EXPECT_TRUE(bl.is_n_page_sized());
}
{
bufferlist bl;
bl.append_zero(1);
EXPECT_FALSE(bl.is_n_page_sized());
}
{
bufferlist bl;
bl.append_zero(CEPH_PAGE_SIZE);
EXPECT_TRUE(bl.is_n_page_sized());
}
}
TEST(BufferList, page_aligned_appender) {
bufferlist bl;
{
auto a = bl.get_page_aligned_appender(5);
a.append("asdf", 4);
cout << bl << std::endl;
ASSERT_EQ(1u, bl.get_num_buffers());
ASSERT_TRUE(bl.contents_equal("asdf", 4));
a.append("asdf", 4);
for (unsigned n = 0; n < 3 * CEPH_PAGE_SIZE; ++n) {
a.append("x", 1);
}
cout << bl << std::endl;
ASSERT_EQ(1u, bl.get_num_buffers());
// verify the beginning
{
bufferlist t;
t.substr_of(bl, 0, 10);
ASSERT_TRUE(t.contents_equal("asdfasdfxx", 10));
}
for (unsigned n = 0; n < 3 * CEPH_PAGE_SIZE; ++n) {
a.append("y", 1);
}
cout << bl << std::endl;
ASSERT_EQ(2u, bl.get_num_buffers());
a.append_zero(42);
// ensure append_zero didn't introduce a fragmentation
ASSERT_EQ(2u, bl.get_num_buffers());
// verify the end is actually zeroed
{
bufferlist t;
t.substr_of(bl, bl.length() - 42, 42);
ASSERT_TRUE(t.is_zero());
}
// let's check whether appending a bufferlist directly to `bl`
// doesn't fragment further C string appends via appender.
{
const auto& initial_back = bl.back();
{
bufferlist src;
src.append("abc", 3);
bl.claim_append(src);
// surely the extra `ptr_node` taken from `src` must get
// reflected in the `bl` instance
ASSERT_EQ(3u, bl.get_num_buffers());
}
// moreover, the next C string-taking `append()` had to
// create anoter `ptr_node` instance but...
a.append("xyz", 3);
ASSERT_EQ(4u, bl.get_num_buffers());
// ... it should point to the same `buffer::raw` instance
// (to the same same block of memory).
ASSERT_EQ(bl.back().raw_c_str(), initial_back.raw_c_str());
}
// check whether it'll take the first byte only and whether
// the auto-flushing works.
for (unsigned n = 0; n < 10 * CEPH_PAGE_SIZE - 3; ++n) {
a.append("zasdf", 1);
}
}
{
cout << bl << std::endl;
ASSERT_EQ(6u, bl.get_num_buffers());
}
// Verify that `page_aligned_appender` does respect the carrying
// `_carriage` over multiple allocations. Although `append_zero()`
// is used here, this affects other members of the append family.
// This part would be crucial for e.g. `encode()`.
{
bl.append_zero(42);
cout << bl << std::endl;
ASSERT_EQ(6u, bl.get_num_buffers());
}
}
TEST(BufferList, rebuild_aligned_size_and_memory) {
const unsigned SIMD_ALIGN = 32;
const unsigned BUFFER_SIZE = 67;
bufferlist bl;
// These two must be concatenated into one memory + size aligned
// bufferptr
{
bufferptr ptr(buffer::create_aligned(2, SIMD_ALIGN));
ptr.set_offset(1);
ptr.set_length(1);
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_aligned(BUFFER_SIZE - 1, SIMD_ALIGN));
bl.append(ptr);
}
// This one must be left alone
{
bufferptr ptr(buffer::create_aligned(BUFFER_SIZE, SIMD_ALIGN));
bl.append(ptr);
}
// These two must be concatenated into one memory + size aligned
// bufferptr
{
bufferptr ptr(buffer::create_aligned(2, SIMD_ALIGN));
ptr.set_offset(1);
ptr.set_length(1);
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_aligned(BUFFER_SIZE - 1, SIMD_ALIGN));
bl.append(ptr);
}
EXPECT_FALSE(bl.is_aligned(SIMD_ALIGN));
EXPECT_FALSE(bl.is_n_align_sized(BUFFER_SIZE));
EXPECT_EQ(BUFFER_SIZE * 3, bl.length());
EXPECT_FALSE(bl.front().is_aligned(SIMD_ALIGN));
EXPECT_FALSE(bl.front().is_n_align_sized(BUFFER_SIZE));
EXPECT_EQ(5U, bl.get_num_buffers());
bl.rebuild_aligned_size_and_memory(BUFFER_SIZE, SIMD_ALIGN);
EXPECT_TRUE(bl.is_aligned(SIMD_ALIGN));
EXPECT_TRUE(bl.is_n_align_sized(BUFFER_SIZE));
EXPECT_EQ(3U, bl.get_num_buffers());
{
/* bug replicator, to test rebuild_aligned_size_and_memory() in the
* scenario where the first bptr is both size and memory aligned and
* the second is 0-length */
bl.clear();
bl.append(bufferptr{buffer::create_aligned(4096, 4096)});
bufferptr ptr(buffer::create_aligned(42, 4096));
/* bl.back().length() must be 0. offset set to 42 guarantees
* the entire list is unaligned. */
bl.append(ptr, 42, 0);
EXPECT_EQ(bl.get_num_buffers(), 2);
EXPECT_EQ(bl.back().length(), 0);
EXPECT_FALSE(bl.is_aligned(4096));
/* rebuild_aligned() calls rebuild_aligned_size_and_memory().
* we assume the rebuild always happens. */
EXPECT_TRUE(bl.rebuild_aligned(4096));
EXPECT_EQ(bl.get_num_buffers(), 1);
}
}
TEST(BufferList, is_zero) {
{
bufferlist bl;
EXPECT_TRUE(bl.is_zero());
}
{
bufferlist bl;
bl.append('A');
EXPECT_FALSE(bl.is_zero());
}
{
bufferlist bl;
bl.append_zero(1);
EXPECT_TRUE(bl.is_zero());
}
for (size_t i = 1; i <= 256; ++i) {
bufferlist bl;
bl.append_zero(i);
EXPECT_TRUE(bl.is_zero());
bl.append('A');
// ensure buffer is a single, contiguous before testing
bl.rebuild();
EXPECT_FALSE(bl.is_zero());
}
}
TEST(BufferList, clear) {
bufferlist bl;
unsigned len = 17;
bl.append_zero(len);
bl.clear();
EXPECT_EQ((unsigned)0, bl.length());
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
}
TEST(BufferList, push_back) {
//
// void push_back(ptr& bp)
//
{
bufferlist bl;
bufferptr ptr;
bl.push_back(ptr);
EXPECT_EQ((unsigned)0, bl.length());
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
}
unsigned len = 17;
{
bufferlist bl;
bl.append('A');
bufferptr ptr(len);
ptr.c_str()[0] = 'B';
bl.push_back(ptr);
EXPECT_EQ((unsigned)(1 + len), bl.length());
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ('B', bl.back()[0]);
const bufferptr& back_bp = bl.back();
EXPECT_EQ(static_cast<instrumented_bptr&>(ptr).get_raw(),
static_cast<const instrumented_bptr&>(back_bp).get_raw());
}
//
// void push_back(ptr&& bp)
//
{
bufferlist bl;
bufferptr ptr;
bl.push_back(std::move(ptr));
EXPECT_EQ((unsigned)0, bl.length());
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
}
{
bufferlist bl;
bl.append('A');
bufferptr ptr(len);
ptr.c_str()[0] = 'B';
bl.push_back(std::move(ptr));
EXPECT_EQ((unsigned)(1 + len), bl.length());
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ('B', bl.buffers().back()[0]);
EXPECT_FALSE(static_cast<instrumented_bptr&>(ptr).get_raw());
}
}
TEST(BufferList, is_contiguous) {
bufferlist bl;
EXPECT_TRUE(bl.is_contiguous());
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
bl.append('A');
EXPECT_TRUE(bl.is_contiguous());
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
bufferptr ptr(1);
bl.push_back(ptr);
EXPECT_FALSE(bl.is_contiguous());
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
}
TEST(BufferList, rebuild) {
{
bufferlist bl;
bufferptr ptr(buffer::create_page_aligned(2));
ptr[0] = 'X';
ptr[1] = 'Y';
ptr.set_offset(1);
ptr.set_length(1);
bl.append(ptr);
EXPECT_FALSE(bl.is_page_aligned());
bl.rebuild();
EXPECT_EQ(1U, bl.length());
EXPECT_EQ('Y', *bl.begin());
}
{
bufferlist bl;
const std::string str(CEPH_PAGE_SIZE, 'X');
bl.append(str.c_str(), str.size());
bl.append(str.c_str(), str.size());
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
//EXPECT_TRUE(bl.is_aligned(CEPH_BUFFER_APPEND_SIZE));
bl.rebuild();
EXPECT_TRUE(bl.is_page_aligned());
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
}
{
bufferlist bl;
char t1[] = "X";
bufferlist a2;
a2.append(t1, 1);
bl.rebuild();
bl.append(a2);
EXPECT_EQ((unsigned)1, bl.length());
bufferlist::iterator p = bl.begin();
char dst[1];
p.copy(1, dst);
EXPECT_EQ(0, memcmp(dst, "X", 1));
}
}
TEST(BufferList, rebuild_page_aligned) {
{
bufferlist bl;
{
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE + 1));
ptr.set_offset(1);
ptr.set_length(CEPH_PAGE_SIZE);
bl.append(ptr);
}
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_FALSE(bl.is_page_aligned());
bl.rebuild_page_aligned();
EXPECT_TRUE(bl.is_page_aligned());
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
}
{
bufferlist bl;
bufferptr ptr(buffer::create_page_aligned(1));
char *p = ptr.c_str();
bl.append(ptr);
bl.rebuild_page_aligned();
EXPECT_EQ(p, bl.front().c_str());
}
{
bufferlist bl;
{
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE));
EXPECT_TRUE(ptr.is_page_aligned());
EXPECT_TRUE(ptr.is_n_page_sized());
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE + 1));
EXPECT_TRUE(ptr.is_page_aligned());
EXPECT_FALSE(ptr.is_n_page_sized());
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_page_aligned(2));
ptr.set_offset(1);
ptr.set_length(1);
EXPECT_FALSE(ptr.is_page_aligned());
EXPECT_FALSE(ptr.is_n_page_sized());
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE - 2));
EXPECT_TRUE(ptr.is_page_aligned());
EXPECT_FALSE(ptr.is_n_page_sized());
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE));
EXPECT_TRUE(ptr.is_page_aligned());
EXPECT_TRUE(ptr.is_n_page_sized());
bl.append(ptr);
}
{
bufferptr ptr(buffer::create_page_aligned(CEPH_PAGE_SIZE + 1));
ptr.set_offset(1);
ptr.set_length(CEPH_PAGE_SIZE);
EXPECT_FALSE(ptr.is_page_aligned());
EXPECT_TRUE(ptr.is_n_page_sized());
bl.append(ptr);
}
EXPECT_EQ((unsigned)6, bl.get_num_buffers());
EXPECT_TRUE((bl.length() & ~CEPH_PAGE_MASK) == 0);
EXPECT_FALSE(bl.is_page_aligned());
bl.rebuild_page_aligned();
EXPECT_TRUE(bl.is_page_aligned());
EXPECT_EQ((unsigned)4, bl.get_num_buffers());
}
}
TEST(BufferList, claim_append) {
bufferlist from;
{
bufferptr ptr(2);
from.append(ptr);
}
bufferlist to;
{
bufferptr ptr(4);
to.append(ptr);
}
EXPECT_EQ((unsigned)4, to.length());
EXPECT_EQ((unsigned)1, to.get_num_buffers());
to.claim_append(from);
EXPECT_EQ((unsigned)(4 + 2), to.length());
EXPECT_EQ((unsigned)4, to.front().length());
EXPECT_EQ((unsigned)2, to.back().length());
EXPECT_EQ((unsigned)2, to.get_num_buffers());
EXPECT_EQ((unsigned)0, from.get_num_buffers());
EXPECT_EQ((unsigned)0, from.length());
}
TEST(BufferList, begin) {
bufferlist bl;
bl.append("ABC");
bufferlist::iterator i = bl.begin();
EXPECT_EQ('A', *i);
}
TEST(BufferList, end) {
bufferlist bl;
bl.append("AB");
bufferlist::iterator i = bl.end();
bl.append("C");
EXPECT_EQ('C', bl[i.get_off()]);
}
TEST(BufferList, append) {
//
// void append(char c);
//
{
bufferlist bl;
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
bl.append('A');
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
//EXPECT_TRUE(bl.is_aligned(CEPH_BUFFER_APPEND_SIZE));
}
//
// void append(const char *data, unsigned len);
//
{
bufferlist bl(CEPH_PAGE_SIZE);
std::string str(CEPH_PAGE_SIZE * 2, 'X');
bl.append(str.c_str(), str.size());
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ(CEPH_PAGE_SIZE, bl.front().length());
EXPECT_EQ(CEPH_PAGE_SIZE, bl.back().length());
}
//
// void append(const std::string& s);
//
{
bufferlist bl(CEPH_PAGE_SIZE);
std::string str(CEPH_PAGE_SIZE * 2, 'X');
bl.append(str);
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ(CEPH_PAGE_SIZE, bl.front().length());
EXPECT_EQ(CEPH_PAGE_SIZE, bl.back().length());
}
//
// void append(const ptr& bp);
//
{
bufferlist bl;
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
EXPECT_EQ((unsigned)0, bl.length());
{
bufferptr ptr;
bl.append(ptr);
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
EXPECT_EQ((unsigned)0, bl.length());
}
{
bufferptr ptr(3);
bl.append(ptr);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)3, bl.length());
}
}
//
// void append(const ptr& bp, unsigned off, unsigned len);
//
{
bufferlist bl;
bl.append('A');
bufferptr back(bl.back());
bufferptr in(back);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)1, bl.length());
{
PrCtl unset_dumpable;
EXPECT_DEATH(bl.append(in, (unsigned)100, (unsigned)100), "");
}
EXPECT_LT((unsigned)0, in.unused_tail_length());
in.append('B');
bl.append(in, back.end(), 1);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)2, bl.length());
EXPECT_EQ('B', bl[1]);
}
{
bufferlist bl;
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
EXPECT_EQ((unsigned)0, bl.length());
bufferptr ptr(2);
ptr.set_length(0);
ptr.append("AB", 2);
bl.append(ptr, 1, 1);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)1, bl.length());
}
//
// void append(const list& bl);
//
{
bufferlist bl;
bl.append('A');
bufferlist other;
other.append('B');
bl.append(other);
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ('B', bl[1]);
}
//
// void append(std::istream& in);
//
{
bufferlist bl;
std::string expected("ABC\nDEF\n");
std::istringstream is("ABC\n\nDEF");
bl.append(is);
EXPECT_EQ(0, ::memcmp(expected.c_str(), bl.c_str(), expected.size()));
EXPECT_EQ(expected.size(), bl.length());
}
//
// void append(ptr&& bp);
//
{
bufferlist bl;
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
EXPECT_EQ((unsigned)0, bl.length());
{
bufferptr ptr;
bl.append(std::move(ptr));
EXPECT_EQ((unsigned)0, bl.get_num_buffers());
EXPECT_EQ((unsigned)0, bl.length());
}
{
bufferptr ptr(3);
bl.append(std::move(ptr));
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)3, bl.length());
EXPECT_FALSE(static_cast<instrumented_bptr&>(ptr).get_raw());
}
}
}
TEST(BufferList, append_hole) {
{
bufferlist bl;
auto filler = bl.append_hole(1);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)1, bl.length());
bl.append("BC", 2);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)3, bl.length());
const char a = 'A';
filler.copy_in((unsigned)1, &a);
EXPECT_EQ((unsigned)3, bl.length());
EXPECT_EQ(0, ::memcmp("ABC", bl.c_str(), 3));
}
{
bufferlist bl;
bl.append('A');
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)1, bl.length());
auto filler = bl.append_hole(1);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)2, bl.length());
bl.append('C');
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)3, bl.length());
const char b = 'B';
filler.copy_in((unsigned)1, &b);
EXPECT_EQ((unsigned)3, bl.length());
EXPECT_EQ(0, ::memcmp("ABC", bl.c_str(), 3));
}
}
TEST(BufferList, append_zero) {
bufferlist bl;
bl.append('A');
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)1, bl.length());
bl.append_zero(1);
EXPECT_EQ((unsigned)1, bl.get_num_buffers());
EXPECT_EQ((unsigned)2, bl.length());
EXPECT_EQ('\0', bl[1]);
}
TEST(BufferList, operator_brackets) {
bufferlist bl;
EXPECT_THROW(bl[1], buffer::end_of_buffer);
bl.append('A');
bufferlist other;
other.append('B');
bl.append(other);
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ('B', bl[1]);
}
TEST(BufferList, c_str) {
bufferlist bl;
EXPECT_EQ((const char*)NULL, bl.c_str());
bl.append('A');
bufferlist other;
other.append('B');
bl.append(other);
EXPECT_EQ((unsigned)2, bl.get_num_buffers());
EXPECT_EQ(0, ::memcmp("AB", bl.c_str(), 2));
}
TEST(BufferList, c_str_carriage) {
// verify the c_str() optimization for carriage handling
buffer::ptr bp("A", 1);
bufferlist bl;
bl.append(bp);
bl.append('B');
EXPECT_EQ(2U, bl.get_num_buffers());
EXPECT_EQ(2U, bl.length());
// this should leave an empty bptr for carriage at the end of the bl
bl.splice(1, 1);
EXPECT_EQ(2U, bl.get_num_buffers());
EXPECT_EQ(1U, bl.length());
std::ignore = bl.c_str();
// if we have an empty bptr at the end, we don't need to rebuild
EXPECT_EQ(2U, bl.get_num_buffers());
}
TEST(BufferList, substr_of) {
bufferlist bl;
EXPECT_THROW(bl.substr_of(bl, 1, 1), buffer::end_of_buffer);
const char *s[] = {
"ABC",
"DEF",
"GHI",
"JKL"
};
for (unsigned i = 0; i < 4; i++) {
bufferptr ptr(s[i], strlen(s[i]));
bl.push_back(ptr);
}
EXPECT_EQ((unsigned)4, bl.get_num_buffers());
bufferlist other;
other.append("TO BE CLEARED");
other.substr_of(bl, 4, 4);
EXPECT_EQ((unsigned)2, other.get_num_buffers());
EXPECT_EQ((unsigned)4, other.length());
EXPECT_EQ(0, ::memcmp("EFGH", other.c_str(), 4));
}
TEST(BufferList, splice) {
bufferlist bl;
EXPECT_THROW(bl.splice(1, 1), buffer::end_of_buffer);
const char *s[] = {
"ABC",
"DEF",
"GHI",
"JKL"
};
for (unsigned i = 0; i < 4; i++) {
bufferptr ptr(s[i], strlen(s[i]));
bl.push_back(ptr);
}
EXPECT_EQ((unsigned)4, bl.get_num_buffers());
bl.splice(0, 0);
bufferlist other;
other.append('X');
bl.splice(4, 4, &other);
EXPECT_EQ((unsigned)3, other.get_num_buffers());
EXPECT_EQ((unsigned)5, other.length());
EXPECT_EQ(0, ::memcmp("XEFGH", other.c_str(), other.length()));
EXPECT_EQ((unsigned)8, bl.length());
{
bufferlist tmp(bl);
EXPECT_EQ(0, ::memcmp("ABCDIJKL", tmp.c_str(), tmp.length()));
}
bl.splice(4, 4);
EXPECT_EQ((unsigned)4, bl.length());
EXPECT_EQ(0, ::memcmp("ABCD", bl.c_str(), bl.length()));
{
bl.clear();
bufferptr ptr1("0123456789", 10);
bl.push_back(ptr1);
bufferptr ptr2("abcdefghij", 10);
bl.append(ptr2, 5, 5);
other.clear();
bl.splice(10, 4, &other);
EXPECT_EQ((unsigned)11, bl.length());
EXPECT_EQ(0, ::memcmp("fghi", other.c_str(), other.length()));
}
}
TEST(BufferList, write) {
std::ostringstream stream;
bufferlist bl;
bl.append("ABC");
bl.write(1, 2, stream);
EXPECT_EQ("BC", stream.str());
}
TEST(BufferList, encode_base64) {
bufferlist bl;
bl.append("ABCD");
bufferlist other;
bl.encode_base64(other);
const char *expected = "QUJDRA==";
EXPECT_EQ(0, ::memcmp(expected, other.c_str(), strlen(expected)));
}
TEST(BufferList, decode_base64) {
bufferlist bl;
bl.append("QUJDRA==");
bufferlist other;
other.decode_base64(bl);
const char *expected = "ABCD";
EXPECT_EQ(0, ::memcmp(expected, other.c_str(), strlen(expected)));
bufferlist malformed;
malformed.append("QUJDRA");
EXPECT_THROW(other.decode_base64(malformed), buffer::malformed_input);
}
TEST(BufferList, hexdump) {
bufferlist bl;
std::ostringstream stream;
bl.append("013245678901234\0006789012345678901234", 32);
bl.hexdump(stream);
EXPECT_EQ("00000000 30 31 33 32 34 35 36 37 38 39 30 31 32 33 34 00 |013245678901234.|\n"
"00000010 36 37 38 39 30 31 32 33 34 35 36 37 38 39 30 31 |6789012345678901|\n"
"00000020\n",
stream.str());
}
TEST(BufferList, read_file) {
std::string error;
bufferlist bl;
::unlink(FILENAME);
EXPECT_EQ(-ENOENT, bl.read_file("UNLIKELY", &error));
snprintf(cmd, sizeof(cmd), "echo ABC> %s", FILENAME);
EXPECT_EQ(0, ::system(cmd));
#ifndef _WIN32
snprintf(cmd, sizeof(cmd), "chmod 0 %s", FILENAME);
EXPECT_EQ(0, ::system(cmd));
if (getuid() != 0) {
EXPECT_EQ(-EACCES, bl.read_file(FILENAME, &error));
}
snprintf(cmd, sizeof(cmd), "chmod +r %s", FILENAME);
EXPECT_EQ(0, ::system(cmd));
#endif /* _WIN32 */
EXPECT_EQ(0, bl.read_file(FILENAME, &error));
::unlink(FILENAME);
EXPECT_EQ((unsigned)4, bl.length());
std::string actual(bl.c_str(), bl.length());
EXPECT_EQ("ABC\n", actual);
}
TEST(BufferList, read_fd) {
unsigned len = 4;
::unlink(FILENAME);
snprintf(cmd, sizeof(cmd), "echo ABC > %s", FILENAME);
EXPECT_EQ(0, ::system(cmd));
int fd = -1;
bufferlist bl;
EXPECT_EQ(-EBADF, bl.read_fd(fd, len));
fd = ::open(FILENAME, O_RDONLY);
ASSERT_NE(-1, fd);
EXPECT_EQ(len, (unsigned)bl.read_fd(fd, len));
//EXPECT_EQ(CEPH_BUFFER_APPEND_SIZE - len, bl.front().unused_tail_length());
EXPECT_EQ(len, bl.length());
::close(fd);
::unlink(FILENAME);
}
TEST(BufferList, write_file) {
::unlink(FILENAME);
int mode = 0600;
bufferlist bl;
EXPECT_EQ(-ENOENT, bl.write_file("un/like/ly", mode));
bl.append("ABC");
EXPECT_EQ(0, bl.write_file(FILENAME, mode));
struct stat st;
memset(&st, 0, sizeof(st));
ASSERT_EQ(0, ::stat(FILENAME, &st));
#ifndef _WIN32
EXPECT_EQ((unsigned)(mode | S_IFREG), st.st_mode);
#endif
::unlink(FILENAME);
}
TEST(BufferList, write_fd) {
::unlink(FILENAME);
int fd = ::open(FILENAME, O_WRONLY|O_CREAT|O_TRUNC, 0600);
ASSERT_NE(-1, fd);
bufferlist bl;
for (unsigned i = 0; i < IOV_MAX * 2; i++) {
bufferptr ptr("A", 1);
bl.push_back(ptr);
}
EXPECT_EQ(0, bl.write_fd(fd));
::close(fd);
struct stat st;
memset(&st, 0, sizeof(st));
ASSERT_EQ(0, ::stat(FILENAME, &st));
EXPECT_EQ(IOV_MAX * 2, st.st_size);
::unlink(FILENAME);
}
TEST(BufferList, write_fd_offset) {
::unlink(FILENAME);
int fd = ::open(FILENAME, O_WRONLY|O_CREAT|O_TRUNC, 0600);
ASSERT_NE(-1, fd);
bufferlist bl;
for (unsigned i = 0; i < IOV_MAX * 2; i++) {
bufferptr ptr("A", 1);
bl.push_back(ptr);
}
uint64_t offset = 200;
EXPECT_EQ(0, bl.write_fd(fd, offset));
::close(fd);
struct stat st;
memset(&st, 0, sizeof(st));
ASSERT_EQ(0, ::stat(FILENAME, &st));
EXPECT_EQ(IOV_MAX * 2 + offset, (unsigned)st.st_size);
::unlink(FILENAME);
}
TEST(BufferList, crc32c) {
bufferlist bl;
__u32 crc = 0;
bl.append("A");
crc = bl.crc32c(crc);
EXPECT_EQ((unsigned)0xB3109EBF, crc);
crc = bl.crc32c(crc);
EXPECT_EQ((unsigned)0x5FA5C0CC, crc);
}
TEST(BufferList, crc32c_append) {
bufferlist bl1;
bufferlist bl2;
for (int j = 0; j < 200; ++j) {
bufferlist bl;
for (int i = 0; i < 200; ++i) {
char x = rand();
bl.append(x);
bl1.append(x);
}
bl.crc32c(rand()); // mess with the cached bufferptr crc values
bl2.append(bl);
}
ASSERT_EQ(bl1.crc32c(0), bl2.crc32c(0));
}
TEST(BufferList, crc32c_zeros) {
char buffer[4*1024];
for (size_t i=0; i < sizeof(buffer); i++)
{
buffer[i] = i;
}
bufferlist bla;
bufferlist blb;
for (size_t j=0; j < 1000; j++)
{
bufferptr a(buffer, sizeof(buffer));
bla.push_back(a);
uint32_t crca = bla.crc32c(111);
blb.push_back(a);
uint32_t crcb = ceph_crc32c(111, (unsigned char*)blb.c_str(), blb.length());
EXPECT_EQ(crca, crcb);
}
}
TEST(BufferList, crc32c_append_perf) {
int len = 256 * 1024 * 1024;
bufferptr a(len);
bufferptr b(len);
bufferptr c(len);
bufferptr d(len);
std::cout << "populating large buffers (a, b=c=d)" << std::endl;
char *pa = a.c_str();
char *pb = b.c_str();
char *pc = c.c_str();
char *pd = c.c_str();
for (int i=0; i<len; i++) {
pa[i] = (i & 0xff) ^ 73;
pb[i] = (i & 0xff) ^ 123;
pc[i] = (i & 0xff) ^ 123;
pd[i] = (i & 0xff) ^ 123;
}
// track usage of cached crcs
buffer::track_cached_crc(true);
[[maybe_unused]] int base_cached = buffer::get_cached_crc();
[[maybe_unused]] int base_cached_adjusted = buffer::get_cached_crc_adjusted();
bufferlist bla;
bla.push_back(a);
bufferlist blb;
blb.push_back(b);
{
utime_t start = ceph_clock_now();
uint32_t r = bla.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)len / (float)(1024*1024) / (float)(end - start);
std::cout << "a.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 1138817026u);
}
ceph_assert(buffer::get_cached_crc() == 0 + base_cached);
{
utime_t start = ceph_clock_now();
uint32_t r = bla.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)len / (float)(1024*1024) / (float)(end - start);
std::cout << "a.crc32c(0) (again) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 1138817026u);
}
ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
{
utime_t start = ceph_clock_now();
uint32_t r = bla.crc32c(5);
utime_t end = ceph_clock_now();
float rate = (float)len / (float)(1024*1024) / (float)(end - start);
std::cout << "a.crc32c(5) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 3239494520u);
}
ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
ceph_assert(buffer::get_cached_crc_adjusted() == 1 + base_cached_adjusted);
{
utime_t start = ceph_clock_now();
uint32_t r = bla.crc32c(5);
utime_t end = ceph_clock_now();
float rate = (float)len / (float)(1024*1024) / (float)(end - start);
std::cout << "a.crc32c(5) (again) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 3239494520u);
}
ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
ceph_assert(buffer::get_cached_crc_adjusted() == 2 + base_cached_adjusted);
{
utime_t start = ceph_clock_now();
uint32_t r = blb.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)len / (float)(1024*1024) / (float)(end - start);
std::cout << "b.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2481791210u);
}
ceph_assert(buffer::get_cached_crc() == 1 + base_cached);
{
utime_t start = ceph_clock_now();
uint32_t r = blb.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)len / (float)(1024*1024) / (float)(end - start);
std::cout << "b.crc32c(0) (again)= " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2481791210u);
}
ceph_assert(buffer::get_cached_crc() == 2 + base_cached);
bufferlist ab;
ab.push_back(a);
ab.push_back(b);
{
utime_t start = ceph_clock_now();
uint32_t r = ab.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)ab.length() / (float)(1024*1024) / (float)(end - start);
std::cout << "ab.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2988268779u);
}
ceph_assert(buffer::get_cached_crc() == 3 + base_cached);
ceph_assert(buffer::get_cached_crc_adjusted() == 3 + base_cached_adjusted);
bufferlist ac;
ac.push_back(a);
ac.push_back(c);
{
utime_t start = ceph_clock_now();
uint32_t r = ac.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)ac.length() / (float)(1024*1024) / (float)(end - start);
std::cout << "ac.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 2988268779u);
}
ceph_assert(buffer::get_cached_crc() == 4 + base_cached);
ceph_assert(buffer::get_cached_crc_adjusted() == 3 + base_cached_adjusted);
bufferlist ba;
ba.push_back(b);
ba.push_back(a);
{
utime_t start = ceph_clock_now();
uint32_t r = ba.crc32c(0);
utime_t end = ceph_clock_now();
float rate = (float)ba.length() / (float)(1024*1024) / (float)(end - start);
std::cout << "ba.crc32c(0) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 169240695u);
}
ceph_assert(buffer::get_cached_crc() == 5 + base_cached);
ceph_assert(buffer::get_cached_crc_adjusted() == 4 + base_cached_adjusted);
{
utime_t start = ceph_clock_now();
uint32_t r = ba.crc32c(5);
utime_t end = ceph_clock_now();
float rate = (float)ba.length() / (float)(1024*1024) / (float)(end - start);
std::cout << "ba.crc32c(5) = " << r << " at " << rate << " MB/sec" << std::endl;
ASSERT_EQ(r, 1265464778u);
}
ceph_assert(buffer::get_cached_crc() == 5 + base_cached);
ceph_assert(buffer::get_cached_crc_adjusted() == 6 + base_cached_adjusted);
cout << "crc cache hits (same start) = " << buffer::get_cached_crc() << std::endl;
cout << "crc cache hits (adjusted) = " << buffer::get_cached_crc_adjusted() << std::endl;
}
TEST(BufferList, compare) {
bufferlist a;
a.append("A");
bufferlist ab; // AB in segments
ab.append(bufferptr("A", 1));
ab.append(bufferptr("B", 1));
bufferlist ac;
ac.append("AC");
//
// bool operator>(bufferlist& l, bufferlist& r)
//
ASSERT_FALSE(a > ab);
ASSERT_TRUE(ab > a);
ASSERT_TRUE(ac > ab);
ASSERT_FALSE(ab > ac);
ASSERT_FALSE(ab > ab);
//
// bool operator>=(bufferlist& l, bufferlist& r)
//
ASSERT_FALSE(a >= ab);
ASSERT_TRUE(ab >= a);
ASSERT_TRUE(ac >= ab);
ASSERT_FALSE(ab >= ac);
ASSERT_TRUE(ab >= ab);
//
// bool operator<(bufferlist& l, bufferlist& r)
//
ASSERT_TRUE(a < ab);
ASSERT_FALSE(ab < a);
ASSERT_FALSE(ac < ab);
ASSERT_TRUE(ab < ac);
ASSERT_FALSE(ab < ab);
//
// bool operator<=(bufferlist& l, bufferlist& r)
//
ASSERT_TRUE(a <= ab);
ASSERT_FALSE(ab <= a);
ASSERT_FALSE(ac <= ab);
ASSERT_TRUE(ab <= ac);
ASSERT_TRUE(ab <= ab);
//
// bool operator==(bufferlist &l, bufferlist &r)
//
ASSERT_FALSE(a == ab);
ASSERT_FALSE(ac == ab);
ASSERT_TRUE(ab == ab);
}
TEST(BufferList, ostream) {
std::ostringstream stream;
bufferlist bl;
const char *s[] = {
"ABC",
"DEF"
};
for (unsigned i = 0; i < 2; i++) {
bufferptr ptr(s[i], strlen(s[i]));
bl.push_back(ptr);
}
stream << bl;
std::cerr << stream.str() << std::endl;
EXPECT_GT(stream.str().size(), stream.str().find("list(len=6,"));
EXPECT_GT(stream.str().size(), stream.str().find("len 3 nref 1),\n"));
EXPECT_GT(stream.str().size(), stream.str().find("len 3 nref 1)\n"));
}
TEST(BufferList, zero) {
//
// void zero()
//
{
bufferlist bl;
bl.append('A');
EXPECT_EQ('A', bl[0]);
bl.zero();
EXPECT_EQ('\0', bl[0]);
}
//
// void zero(unsigned o, unsigned l)
//
const char *s[] = {
"ABC",
"DEF",
"GHI",
"KLM"
};
{
bufferlist bl;
bufferptr ptr(s[0], strlen(s[0]));
bl.push_back(ptr);
bl.zero((unsigned)0, (unsigned)1);
EXPECT_EQ(0, ::memcmp("\0BC", bl.c_str(), 3));
}
{
bufferlist bl;
for (unsigned i = 0; i < 4; i++) {
bufferptr ptr(s[i], strlen(s[i]));
bl.push_back(ptr);
}
{
PrCtl unset_dumpable;
EXPECT_DEATH(bl.zero((unsigned)0, (unsigned)2000), "");
}
bl.zero((unsigned)2, (unsigned)5);
EXPECT_EQ(0, ::memcmp("AB\0\0\0\0\0HIKLM", bl.c_str(), 9));
}
{
bufferlist bl;
for (unsigned i = 0; i < 4; i++) {
bufferptr ptr(s[i], strlen(s[i]));
bl.push_back(ptr);
}
bl.zero((unsigned)3, (unsigned)3);
EXPECT_EQ(0, ::memcmp("ABC\0\0\0GHIKLM", bl.c_str(), 9));
}
{
bufferlist bl;
bufferptr ptr1(4);
bufferptr ptr2(4);
memset(ptr1.c_str(), 'a', 4);
memset(ptr2.c_str(), 'b', 4);
bl.append(ptr1);
bl.append(ptr2);
bl.zero((unsigned)2, (unsigned)4);
EXPECT_EQ(0, ::memcmp("aa\0\0\0\0bb", bl.c_str(), 8));
}
}
TEST(BufferList, EmptyAppend) {
bufferlist bl;
bufferptr ptr;
bl.push_back(ptr);
ASSERT_EQ(bl.begin().end(), 1);
}
TEST(BufferList, InternalCarriage) {
ceph::bufferlist bl;
EXPECT_EQ(bl.get_num_buffers(), 0u);
encode(int64_t(42), bl);
EXPECT_EQ(bl.get_num_buffers(), 1u);
{
ceph::bufferlist bl_with_foo;
bl_with_foo.append("foo", 3);
EXPECT_EQ(bl_with_foo.length(), 3u);
EXPECT_EQ(bl_with_foo.get_num_buffers(), 1u);
bl.append(bl_with_foo);
EXPECT_EQ(bl.get_num_buffers(), 2u);
}
encode(int64_t(24), bl);
EXPECT_EQ(bl.get_num_buffers(), 3u);
}
TEST(BufferList, ContiguousAppender) {
ceph::bufferlist bl;
EXPECT_EQ(bl.get_num_buffers(), 0u);
// we expect a flush in ~contiguous_appender
{
auto ap = bl.get_contiguous_appender(100);
denc(int64_t(42), ap);
EXPECT_EQ(bl.get_num_buffers(), 1u);
// append bufferlist with single ptr inside. This should
// commit changes to bl::_len and the underlying bp::len.
{
ceph::bufferlist bl_with_foo;
bl_with_foo.append("foo", 3);
EXPECT_EQ(bl_with_foo.length(), 3u);
EXPECT_EQ(bl_with_foo.get_num_buffers(), 1u);
ap.append(bl_with_foo);
// 3 as the ap::append(const bl&) splits the bp with free
// space.
EXPECT_EQ(bl.get_num_buffers(), 3u);
}
denc(int64_t(24), ap);
EXPECT_EQ(bl.get_num_buffers(), 3u);
EXPECT_EQ(bl.length(), sizeof(int64_t) + 3u);
}
EXPECT_EQ(bl.length(), 2u * sizeof(int64_t) + 3u);
}
TEST(BufferList, TestPtrAppend) {
bufferlist bl;
char correct[MAX_TEST];
int curpos = 0;
int length = random() % 5 > 0 ? random() % 1000 : 0;
while (curpos + length < MAX_TEST) {
if (!length) {
bufferptr ptr;
bl.push_back(ptr);
} else {
char *current = correct + curpos;
for (int i = 0; i < length; ++i) {
char next = random() % 255;
correct[curpos++] = next;
}
bufferptr ptr(current, length);
bl.append(ptr);
}
length = random() % 5 > 0 ? random() % 1000 : 0;
}
ASSERT_EQ(memcmp(bl.c_str(), correct, curpos), 0);
}
TEST(BufferList, TestDirectAppend) {
bufferlist bl;
char correct[MAX_TEST];
int curpos = 0;
int length = random() % 5 > 0 ? random() % 1000 : 0;
while (curpos + length < MAX_TEST) {
char *current = correct + curpos;
for (int i = 0; i < length; ++i) {
char next = random() % 255;
correct[curpos++] = next;
}
bl.append(current, length);
length = random() % 5 > 0 ? random() % 1000 : 0;
}
ASSERT_EQ(memcmp(bl.c_str(), correct, curpos), 0);
}
TEST(BufferList, TestCopyAll) {
const static size_t BIG_SZ = 10737414;
std::shared_ptr <unsigned char> big(
(unsigned char*)malloc(BIG_SZ), free);
unsigned char c = 0;
for (size_t i = 0; i < BIG_SZ; ++i) {
big.get()[i] = c++;
}
bufferlist bl;
bl.append((const char*)big.get(), BIG_SZ);
bufferlist::iterator i = bl.begin();
bufferlist bl2;
i.copy_all(bl2);
ASSERT_EQ(bl2.length(), BIG_SZ);
std::shared_ptr <unsigned char> big2(
(unsigned char*)malloc(BIG_SZ), free);
bl2.begin().copy(BIG_SZ, (char*)big2.get());
ASSERT_EQ(memcmp(big.get(), big2.get(), BIG_SZ), 0);
}
TEST(BufferList, InvalidateCrc) {
const static size_t buffer_size = 262144;
std::shared_ptr <unsigned char> big(
(unsigned char*)malloc(buffer_size), free);
unsigned char c = 0;
char* ptr = (char*) big.get();
char* inptr;
for (size_t i = 0; i < buffer_size; ++i) {
ptr[i] = c++;
}
bufferlist bl;
// test for crashes (shouldn't crash)
bl.invalidate_crc();
// put data into bufferlist
bl.append((const char*)big.get(), buffer_size);
// get its crc
__u32 crc = bl.crc32c(0);
// modify data in bl without its knowledge
inptr = (char*) bl.c_str();
c = 0;
for (size_t i = 0; i < buffer_size; ++i) {
inptr[i] = c--;
}
// make sure data in bl are now different than in big
EXPECT_NE(memcmp((void*) ptr, (void*) inptr, buffer_size), 0);
// crc should remain the same
__u32 new_crc = bl.crc32c(0);
EXPECT_EQ(crc, new_crc);
// force crc invalidate, check if it is updated
bl.invalidate_crc();
EXPECT_NE(crc, bl.crc32c(0));
}
TEST(BufferList, TestIsProvidedBuffer) {
char buff[100];
bufferlist bl;
bl.push_back(buffer::create_static(100, buff));
ASSERT_TRUE(bl.is_provided_buffer(buff));
bl.append_zero(100);
ASSERT_FALSE(bl.is_provided_buffer(buff));
}
TEST(BufferList, DISABLED_DanglingLastP) {
bufferlist bl;
{
// previously we're using the unsharable buffer type to distinguish
// the last_p-specific problem from the generic crosstalk issues we
// had since the very beginning:
// https://gist.github.com/rzarzynski/aed18372e88aed392101adac3bd87bbc
// this is no longer possible as `buffer::create_unsharable()` has
// been dropped.
bufferptr bp(buffer::create(10));
bp.copy_in(0, 3, "XXX");
bl.push_back(std::move(bp));
EXPECT_EQ(0, ::memcmp("XXX", bl.c_str(), 3));
// let `copy_in` to set `last_p` member of bufferlist
bl.begin().copy_in(2, "AB");
EXPECT_EQ(0, ::memcmp("ABX", bl.c_str(), 3));
}
bufferlist empty;
// before the fix this would have left `last_p` unchanged leading to
// the dangerous dangling state – keep in mind that the initial,
// unsharable bptr will be freed.
bl = const_cast<const bufferlist&>(empty);
bl.append("123");
// we must continue from where the previous copy_in had finished.
// Otherwise `bl::copy_in` will call `seek()` and refresh `last_p`.
bl.begin(2).copy_in(1, "C");
EXPECT_EQ(0, ::memcmp("12C", bl.c_str(), 3));
}
TEST(BufferHash, all) {
{
bufferlist bl;
bl.append("A");
bufferhash hash;
EXPECT_EQ((unsigned)0, hash.digest());
hash.update(bl);
EXPECT_EQ((unsigned)0xB3109EBF, hash.digest());
hash.update(bl);
EXPECT_EQ((unsigned)0x5FA5C0CC, hash.digest());
}
{
bufferlist bl;
bl.append("A");
bufferhash hash;
EXPECT_EQ((unsigned)0, hash.digest());
bufferhash& returned_hash = hash << bl;
EXPECT_EQ(&returned_hash, &hash);
EXPECT_EQ((unsigned)0xB3109EBF, hash.digest());
}
}
/*
* Local Variables:
* compile-command: "cd .. ; make unittest_bufferlist &&
* ulimit -s unlimited ; valgrind \
* --max-stackframe=20000000 --tool=memcheck \
* ./unittest_bufferlist # --gtest_filter=BufferList.constructors"
* End:
*/
| 80,980 | 25.258431 | 98 |
cc
|
null |
ceph-main/src/test/buildtest_skeleton.cc
|
#include "common/common_init.h"
/* This program exists to test that we can build libcommon without
* referencing g_ceph_context
*
* This program will go away as soon as we actually don't use g_ceph_context in
* more programs. Obviously, at that point, those programs will provide an
* equivalent test.
*/
int main(int argc, char **argv)
{
return 0;
}
| 360 | 24.785714 | 79 |
cc
|
null |
ceph-main/src/test/ceph_argparse.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/ceph_argparse.h"
#include "gtest/gtest.h"
#include <vector>
#include "include/stringify.h"
using namespace std;
/* Holds a std::vector with C-strings.
* Will free() them properly in the destructor.
*
* Note: the ceph_argparse functions modify the vector, removing elements as
* they find them. So we keep a parallel vector, orig, to make sure that we
* never forget to delete a string.
*/
class VectorContainer
{
public:
explicit VectorContainer(const char** arr_) {
for (const char **a = arr_; *a; ++a) {
const char *str = (const char*)strdup(*a);
arr.push_back(str);
orig.push_back(str);
}
}
~VectorContainer() {
for (std::vector<const char*>::iterator i = orig.begin();
i != orig.end(); ++i)
{
free((void*)*i);
}
}
void refresh() {
arr.assign(orig.begin(), orig.end());
}
std::vector < const char* > arr;
private:
std::vector < const char* > orig;
};
TEST(CephArgParse, SimpleArgParse) {
const char *BAR5[] = { "./myprog", "--bar", "5", NULL };
const char *FOO[] = { "./myprog", "--foo", "--baz", NULL };
const char *NONE[] = { "./myprog", NULL };
bool found_foo = false;
std::string found_bar;
VectorContainer bar5(BAR5);
for (std::vector<const char*>::iterator i = bar5.arr.begin();
i != bar5.arr.end(); )
{
if (ceph_argparse_flag(bar5.arr, i, "--foo", (char*)NULL)) {
found_foo = true;
}
else if (ceph_argparse_witharg(bar5.arr, i, &found_bar, "--bar", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_foo, false);
ASSERT_EQ(found_bar, "5");
found_foo = false;
found_bar = "";
bool baz_found = false;
std::string found_baz = "";
VectorContainer foo(FOO);
ostringstream err;
for (std::vector<const char*>::iterator i = foo.arr.begin();
i != foo.arr.end(); )
{
if (ceph_argparse_flag(foo.arr, i, "--foo", (char*)NULL)) {
found_foo = true;
}
else if (ceph_argparse_witharg(foo.arr, i, &found_bar, "--bar", (char*)NULL)) {
}
else if (ceph_argparse_witharg(foo.arr, i, &found_baz, err, "--baz", (char*)NULL)) {
ASSERT_NE(string(""), err.str());
baz_found = true;
}
else
++i;
}
ASSERT_EQ(found_foo, true);
ASSERT_EQ(found_bar, "");
ASSERT_EQ(baz_found, true);
ASSERT_EQ(found_baz, "");
found_foo = false;
found_bar = "";
VectorContainer none(NONE);
for (std::vector<const char*>::iterator i = none.arr.begin();
i != none.arr.end(); )
{
if (ceph_argparse_flag(none.arr, i, "--foo", (char*)NULL)) {
found_foo = true;
}
else if (ceph_argparse_witharg(none.arr, i, &found_bar, "--bar", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_foo, false);
ASSERT_EQ(found_bar, "");
}
TEST(CephArgParse, DoubleDash) {
const char *ARGS[] = { "./myprog", "--foo", "5", "--", "--bar", "6", NULL };
int foo = -1, bar = -1;
VectorContainer args(ARGS);
for (std::vector<const char*>::iterator i = args.arr.begin();
i != args.arr.end(); )
{
std::string myarg;
if (ceph_argparse_double_dash(args.arr, i)) {
break;
}
else if (ceph_argparse_witharg(args.arr, i, &myarg, "--foo", (char*)NULL)) {
foo = atoi(myarg.c_str());
}
else if (ceph_argparse_witharg(args.arr, i, &myarg, "--bar", (char*)NULL)) {
bar = atoi(myarg.c_str());
}
else
++i;
}
ASSERT_EQ(foo, 5);
ASSERT_EQ(bar, -1);
}
TEST(CephArgParse, WithDashesAndUnderscores) {
const char *BAZSTUFF1[] = { "./myprog", "--goo", "--baz-stuff", "50", "--end", NULL };
const char *BAZSTUFF2[] = { "./myprog", "--goo2", "--baz_stuff", "50", NULL };
const char *BAZSTUFF3[] = { "./myprog", "--goo2", "--baz-stuff=50", "50", NULL };
const char *BAZSTUFF4[] = { "./myprog", "--goo2", "--baz_stuff=50", "50", NULL };
const char *NONE1[] = { "./myprog", NULL };
const char *NONE2[] = { "./myprog", "--goo2", "--baz_stuff2", "50", NULL };
const char *NONE3[] = { "./myprog", "--goo2", "__baz_stuff", "50", NULL };
// as flag
std::string found_baz;
VectorContainer bazstuff1(BAZSTUFF1);
for (std::vector<const char*>::iterator i = bazstuff1.arr.begin();
i != bazstuff1.arr.end(); )
{
if (ceph_argparse_flag(bazstuff1.arr, i, "--baz-stuff", (char*)NULL)) {
found_baz = "true";
}
else
++i;
}
ASSERT_EQ(found_baz, "true");
// as flag
found_baz = "";
VectorContainer bazstuff2(BAZSTUFF2);
for (std::vector<const char*>::iterator i = bazstuff2.arr.begin();
i != bazstuff2.arr.end(); )
{
if (ceph_argparse_flag(bazstuff2.arr, i, "--baz-stuff", (char*)NULL)) {
found_baz = "true";
}
else
++i;
}
ASSERT_EQ(found_baz, "true");
// with argument
found_baz = "";
bazstuff1.refresh();
for (std::vector<const char*>::iterator i = bazstuff1.arr.begin();
i != bazstuff1.arr.end(); )
{
if (ceph_argparse_witharg(bazstuff1.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "50");
// with argument
found_baz = "";
bazstuff2.refresh();
for (std::vector<const char*>::iterator i = bazstuff2.arr.begin();
i != bazstuff2.arr.end(); )
{
if (ceph_argparse_witharg(bazstuff2.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "50");
// with argument
found_baz = "";
VectorContainer bazstuff3(BAZSTUFF3);
for (std::vector<const char*>::iterator i = bazstuff3.arr.begin();
i != bazstuff3.arr.end(); )
{
if (ceph_argparse_witharg(bazstuff3.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "50");
// with argument
found_baz = "";
VectorContainer bazstuff4(BAZSTUFF4);
for (std::vector<const char*>::iterator i = bazstuff4.arr.begin();
i != bazstuff4.arr.end(); )
{
if (ceph_argparse_witharg(bazstuff4.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "50");
// not found
found_baz = "";
VectorContainer none1(NONE1);
for (std::vector<const char*>::iterator i = none1.arr.begin();
i != none1.arr.end(); )
{
if (ceph_argparse_flag(none1.arr, i, "--baz-stuff", (char*)NULL)) {
found_baz = "true";
}
else if (ceph_argparse_witharg(none1.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "");
// not found
found_baz = "";
VectorContainer none2(NONE2);
for (std::vector<const char*>::iterator i = none2.arr.begin();
i != none2.arr.end(); )
{
if (ceph_argparse_flag(none2.arr, i, "--baz-stuff", (char*)NULL)) {
found_baz = "true";
}
else if (ceph_argparse_witharg(none2.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "");
// not found
found_baz = "";
VectorContainer none3(NONE3);
for (std::vector<const char*>::iterator i = none3.arr.begin();
i != none3.arr.end(); )
{
if (ceph_argparse_flag(none3.arr, i, "--baz-stuff", (char*)NULL)) {
found_baz = "true";
}
else if (ceph_argparse_witharg(none3.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) {
}
else
++i;
}
ASSERT_EQ(found_baz, "");
}
TEST(CephArgParse, WithFloat) {
const char *BAZSTUFF1[] = { "./myprog", "--foo", "50.5", "--bar", "52", NULL };
VectorContainer bazstuff1(BAZSTUFF1);
ostringstream err;
float foo;
int bar = -1;
for (std::vector<const char*>::iterator i = bazstuff1.arr.begin();
i != bazstuff1.arr.end(); )
{
if (ceph_argparse_double_dash(bazstuff1.arr, i)) {
break;
} else if (ceph_argparse_witharg(bazstuff1.arr, i, &foo, err, "--foo", (char*)NULL)) {
ASSERT_EQ(string(""), err.str());
} else if (ceph_argparse_witharg(bazstuff1.arr, i, &bar, err, "--bar", (char*)NULL)) {
ASSERT_EQ(string(""), err.str());
}
else {
++i;
}
}
ASSERT_EQ(foo, 50.5);
ASSERT_EQ(bar, 52);
}
TEST(CephArgParse, WithInt) {
const char *BAZSTUFF1[] = { "./myprog", "--foo", "50", "--bar", "52", NULL };
const char *BAZSTUFF2[] = { "./myprog", "--foo", "--bar", "52", NULL };
const char *BAZSTUFF3[] = { "./myprog", "--foo", "40", "--", "--bar", "42", NULL };
// normal test
VectorContainer bazstuff1(BAZSTUFF1);
ostringstream err;
int foo = -1, bar = -1;
for (std::vector<const char*>::iterator i = bazstuff1.arr.begin();
i != bazstuff1.arr.end(); )
{
if (ceph_argparse_double_dash(bazstuff1.arr, i)) {
break;
} else if (ceph_argparse_witharg(bazstuff1.arr, i, &foo, err, "--foo", (char*)NULL)) {
ASSERT_EQ(string(""), err.str());
} else if (ceph_argparse_witharg(bazstuff1.arr, i, &bar, err, "--bar", (char*)NULL)) {
ASSERT_EQ(string(""), err.str());
}
else {
++i;
}
}
ASSERT_EQ(foo, 50);
ASSERT_EQ(bar, 52);
// parse error test
VectorContainer bazstuff2(BAZSTUFF2);
ostringstream err2;
for (std::vector<const char*>::iterator i = bazstuff2.arr.begin();
i != bazstuff2.arr.end(); )
{
if (ceph_argparse_double_dash(bazstuff2.arr, i)) {
break;
} else if (ceph_argparse_witharg(bazstuff2.arr, i, &foo, err2, "--foo", (char*)NULL)) {
ASSERT_NE(string(""), err2.str());
}
else {
++i;
}
}
// double dash test
VectorContainer bazstuff3(BAZSTUFF3);
foo = -1, bar = -1;
for (std::vector<const char*>::iterator i = bazstuff3.arr.begin();
i != bazstuff3.arr.end(); )
{
if (ceph_argparse_double_dash(bazstuff3.arr, i)) {
break;
} else if (ceph_argparse_witharg(bazstuff3.arr, i, &foo, err, "--foo", (char*)NULL)) {
ASSERT_EQ(string(""), err.str());
} else if (ceph_argparse_witharg(bazstuff3.arr, i, &bar, err, "--bar", (char*)NULL)) {
ASSERT_EQ(string(""), err.str());
}
else {
++i;
}
}
ASSERT_EQ(foo, 40);
ASSERT_EQ(bar, -1);
}
TEST(CephArgParse, env_to_vec) {
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
unsetenv("WHATEVER");
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(0u, args.size());
clear_g_str_vec();
env_to_vec(args, "WHATEVER");
EXPECT_EQ(0u, args.size());
args.push_back("a");
setenv("CEPH_ARGS", "b c", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(3u, args.size());
EXPECT_EQ(string("b"), args[0]);
EXPECT_EQ(string("c"), args[1]);
EXPECT_EQ(string("a"), args[2]);
setenv("WHATEVER", "d e", 0);
clear_g_str_vec();
env_to_vec(args, "WHATEVER");
EXPECT_EQ(5u, args.size());
EXPECT_EQ(string("d"), args[0]);
EXPECT_EQ(string("e"), args[1]);
}
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
args.push_back("a");
args.push_back("--");
args.push_back("c");
setenv("CEPH_ARGS", "b -- d", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(5u, args.size());
EXPECT_EQ(string("b"), args[0]);
EXPECT_EQ(string("a"), args[1]);
EXPECT_EQ(string("--"), args[2]);
EXPECT_EQ(string("d"), args[3]);
EXPECT_EQ(string("c"), args[4]);
}
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
args.push_back("a");
args.push_back("--");
setenv("CEPH_ARGS", "b -- c", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(4u, args.size());
EXPECT_EQ(string("b"), args[0]);
EXPECT_EQ(string("a"), args[1]);
EXPECT_EQ(string("--"), args[2]);
EXPECT_EQ(string("c"), args[3]);
}
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
args.push_back("--");
args.push_back("c");
setenv("CEPH_ARGS", "b -- d", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(4u, args.size());
EXPECT_EQ(string("b"), args[0]);
EXPECT_EQ(string("--"), args[1]);
EXPECT_EQ(string("d"), args[2]);
EXPECT_EQ(string("c"), args[3]);
}
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
args.push_back("b");
setenv("CEPH_ARGS", "c -- d", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(4u, args.size());
EXPECT_EQ(string("c"), args[0]);
EXPECT_EQ(string("b"), args[1]);
EXPECT_EQ(string("--"), args[2]);
EXPECT_EQ(string("d"), args[3]);
}
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
args.push_back("a");
args.push_back("--");
args.push_back("c");
setenv("CEPH_ARGS", "-- d", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(4u, args.size());
EXPECT_EQ(string("a"), args[0]);
EXPECT_EQ(string("--"), args[1]);
EXPECT_EQ(string("d"), args[2]);
EXPECT_EQ(string("c"), args[3]);
}
{
std::vector<const char*> args;
unsetenv("CEPH_ARGS");
args.push_back("a");
args.push_back("--");
args.push_back("c");
setenv("CEPH_ARGS", "d", 0);
clear_g_str_vec();
env_to_vec(args);
EXPECT_EQ(4u, args.size());
EXPECT_EQ(string("d"), args[0]);
EXPECT_EQ(string("a"), args[1]);
EXPECT_EQ(string("--"), args[2]);
EXPECT_EQ(string("c"), args[3]);
}
}
TEST(CephArgParse, parse_ip_port_vec) {
struct {
const char *from;
int type;
const char *to;
} tests[] = {
{ "1.2.3.4", entity_addr_t::TYPE_MSGR2,
"v2:1.2.3.4:0/0\n" },
{ "v1:1.2.3.4", entity_addr_t::TYPE_MSGR2,
"v1:1.2.3.4:0/0\n" },
{ "1.2.3.4", entity_addr_t::TYPE_LEGACY,
"v1:1.2.3.4:0/0\n" },
{ "[::],1.2.3.4", entity_addr_t::TYPE_LEGACY,
"v1:[::]:0/0\nv1:1.2.3.4:0/0\n" },
{ "v2:1.2.3.4:111,v1:5.6.7.8:222", entity_addr_t::TYPE_LEGACY,
"v2:1.2.3.4:111/0\nv1:5.6.7.8:222/0\n" },
{ "v2:1.2.3.4:111 v1:5.6.7.8:222", entity_addr_t::TYPE_LEGACY,
"v2:1.2.3.4:111/0\nv1:5.6.7.8:222/0\n" },
{ "[v2:1.2.3.4:111,v1:5.6.7.8:222] [v2:[::]:3300,v1:[::]:6789]",
entity_addr_t::TYPE_LEGACY,
"[v2:1.2.3.4:111/0,v1:5.6.7.8:222/0]\n[v2:[::]:3300/0,v1:[::]:6789/0]\n" },
{ "[v2:1.2.3.4:111,v1:5.6.7.8:222],[v2:[::]:3300,v1:[::]:6789]",
entity_addr_t::TYPE_LEGACY,
"[v2:1.2.3.4:111/0,v1:5.6.7.8:222/0]\n[v2:[::]:3300/0,v1:[::]:6789/0]\n" },
{ 0, 0, 0 },
};
for (unsigned i = 0; tests[i].from; ++i) {
vector<entity_addrvec_t> v;
cout << "-- " << tests[i].from << " type " << tests[i].type
<< " ->\n" << tests[i].to;
ASSERT_TRUE(parse_ip_port_vec(tests[i].from, v, tests[i].type));
string actual;
for (auto s : v) {
actual += stringify(s) + "\n";
}
ASSERT_EQ(actual, tests[i].to);
}
const char *bad[] = {
"1.2.3.4 foo",
0
};
for (unsigned i = 0; bad[i]; ++i) {
vector<entity_addrvec_t> v;
cout << "bad " << bad[i] << std::endl;
ASSERT_FALSE(parse_ip_port_vec(bad[i], v));
}
}
/*
* Local Variables:
* compile-command: "cd .. ; make unittest_ceph_argparse && ./unittest_ceph_argparse"
* End:
*/
| 15,254 | 26.990826 | 93 |
cc
|
null |
ceph-main/src/test/ceph_compatset.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <fstream>
#include <iostream>
#include <errno.h>
#include <sys/stat.h>
#include <signal.h>
#include <ctype.h>
#include <boost/scoped_ptr.hpp>
#include <string>
#include "include/types.h"
#include "include/compat.h"
#include "include/coredumpctl.h"
#include "include/CompatSet.h"
#include "gtest/gtest.h"
#include <vector>
using namespace std;
TEST(CephCompatSet, AllSet) {
CompatSet::FeatureSet compat;
CompatSet::FeatureSet ro;
CompatSet::FeatureSet incompat;
{
PrCtl unset_dumpable;
EXPECT_DEATH(compat.insert(CompatSet::Feature(0, "test")), "");
EXPECT_DEATH(compat.insert(CompatSet::Feature(64, "test")), "");
}
for (int i = 1; i < 64; i++) {
stringstream cname;
cname << string("c") << i;
compat.insert(CompatSet::Feature(i,cname.str().c_str()));
stringstream roname;
roname << string("r") << i;
ro.insert(CompatSet::Feature(i,roname.str().c_str()));
stringstream iname;
iname << string("i") << i;
incompat.insert(CompatSet::Feature(i,iname.str().c_str()));
}
CompatSet tcs(compat, ro, incompat);
//cout << tcs << std::endl;
//Due to a workaround for a bug bit 0 is always set even though it is
//not a legal feature.
EXPECT_EQ(tcs.compat.mask, (uint64_t)0xffffffffffffffff);
EXPECT_EQ(tcs.ro_compat.mask, (uint64_t)0xffffffffffffffff);
EXPECT_EQ(tcs.incompat.mask, (uint64_t)0xffffffffffffffff);
for (int i = 1; i < 64; i++) {
EXPECT_TRUE(tcs.compat.contains(i));
stringstream cname;
cname << string("c") << i;
EXPECT_TRUE(tcs.compat.contains(CompatSet::Feature(i,cname.str().c_str())));
tcs.compat.remove(i);
EXPECT_TRUE(tcs.ro_compat.contains(i));
stringstream roname;
roname << string("r") << i;
EXPECT_TRUE(tcs.ro_compat.contains(CompatSet::Feature(i,roname.str().c_str())));
tcs.ro_compat.remove(i);
EXPECT_TRUE(tcs.incompat.contains(i));
stringstream iname;
iname << string("i") << i;
EXPECT_TRUE(tcs.incompat.contains(CompatSet::Feature(i,iname.str().c_str())));
tcs.incompat.remove(i);
}
//Due to a workaround for a bug bit 0 is always set even though it is
//not a legal feature.
EXPECT_EQ(tcs.compat.mask, (uint64_t)1);
EXPECT_TRUE(tcs.compat.names.empty());
EXPECT_EQ(tcs.ro_compat.mask, (uint64_t)1);
EXPECT_TRUE(tcs.ro_compat.names.empty());
EXPECT_EQ(tcs.incompat.mask, (uint64_t)1);
EXPECT_TRUE(tcs.incompat.names.empty());
}
TEST(CephCompatSet, other) {
CompatSet s1, s2, s1dup;
s1.compat.insert(CompatSet::Feature(1, "c1"));
s1.compat.insert(CompatSet::Feature(2, "c2"));
s1.compat.insert(CompatSet::Feature(32, "c32"));
s1.ro_compat.insert(CompatSet::Feature(63, "r63"));
s1.incompat.insert(CompatSet::Feature(1, "i1"));
s2.compat.insert(CompatSet::Feature(1, "c1"));
s2.compat.insert(CompatSet::Feature(32, "c32"));
s2.ro_compat.insert(CompatSet::Feature(63, "r63"));
s2.incompat.insert(CompatSet::Feature(1, "i1"));
s1dup = s1;
//Check exact match
EXPECT_EQ(s1.compare(s1dup), 0);
//Check superset
EXPECT_EQ(s1.compare(s2), 1);
//Check missing features
EXPECT_EQ(s2.compare(s1), -1);
CompatSet diff = s2.unsupported(s1);
EXPECT_EQ(diff.compat.mask, (uint64_t)1<<2 | 1);
EXPECT_EQ(diff.ro_compat.mask, (uint64_t)1);
EXPECT_EQ(diff.incompat.mask, (uint64_t)1);
CompatSet s3 = s1;
s3.incompat.insert(CompatSet::Feature(4, "i4"));
diff = s1.unsupported(s3);
EXPECT_EQ(diff.compat.mask, (uint64_t)1);
EXPECT_EQ(diff.ro_compat.mask, (uint64_t)1);
EXPECT_EQ(diff.incompat.mask, (uint64_t)1<<4 | 1);
}
TEST(CephCompatSet, merge) {
CompatSet s1, s2, s1dup, s2dup;
s1.compat.insert(CompatSet::Feature(1, "c1"));
s1.compat.insert(CompatSet::Feature(2, "c2"));
s1.compat.insert(CompatSet::Feature(32, "c32"));
s1.ro_compat.insert(CompatSet::Feature(63, "r63"));
s1.incompat.insert(CompatSet::Feature(1, "i1"));
s1dup = s1;
s2.compat.insert(CompatSet::Feature(1, "c1"));
s2.compat.insert(CompatSet::Feature(32, "c32"));
s2.ro_compat.insert(CompatSet::Feature(1, "r1"));
s2.ro_compat.insert(CompatSet::Feature(63, "r63"));
s2.incompat.insert(CompatSet::Feature(1, "i1"));
s2dup = s2;
//Nothing to merge if they are the same
EXPECT_FALSE(s1.merge(s1dup));
EXPECT_FALSE(s2.merge(s2dup));
EXPECT_TRUE(s1.merge(s2));
EXPECT_EQ(s1.compat.mask, (uint64_t)1<<1 | (uint64_t)1<<2 | (uint64_t)1<<32 | 1);
EXPECT_EQ(s1.ro_compat.mask, (uint64_t)1<<1 | (uint64_t)1<<63 | 1);
EXPECT_EQ(s1.incompat.mask, (uint64_t)1<<1 | 1);
EXPECT_TRUE(s2.merge(s1dup));
EXPECT_EQ(s2.compat.mask, (uint64_t)1<<1 | (uint64_t)1<<2 | (uint64_t)1<<32 | 1);
EXPECT_EQ(s2.ro_compat.mask, (uint64_t)1<<1 | (uint64_t)1<<63 | 1);
EXPECT_EQ(s2.incompat.mask, (uint64_t)1<<1 | 1);
}
| 5,161 | 29.72619 | 84 |
cc
|
null |
ceph-main/src/test/ceph_crypto.cc
|
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/ceph_crypto.h"
#include "common/common_init.h"
#include "global/global_init.h"
#include "global/global_context.h"
class CryptoEnvironment: public ::testing::Environment {
public:
void SetUp() override {
ceph::crypto::init();
}
};
TEST(MD5, Simple) {
ceph::crypto::MD5 h;
h.Update((const unsigned char*)"foo", 3);
unsigned char digest[CEPH_CRYPTO_MD5_DIGESTSIZE];
h.Final(digest);
int err;
unsigned char want_digest[CEPH_CRYPTO_MD5_DIGESTSIZE] = {
0xac, 0xbd, 0x18, 0xdb, 0x4c, 0xc2, 0xf8, 0x5c,
0xed, 0xef, 0x65, 0x4f, 0xcc, 0xc4, 0xa4, 0xd8,
};
err = memcmp(digest, want_digest, CEPH_CRYPTO_MD5_DIGESTSIZE);
ASSERT_EQ(0, err);
}
TEST(MD5, MultiUpdate) {
ceph::crypto::MD5 h;
h.Update((const unsigned char*)"", 0);
h.Update((const unsigned char*)"fo", 2);
h.Update((const unsigned char*)"", 0);
h.Update((const unsigned char*)"o", 1);
h.Update((const unsigned char*)"", 0);
unsigned char digest[CEPH_CRYPTO_MD5_DIGESTSIZE];
h.Final(digest);
int err;
unsigned char want_digest[CEPH_CRYPTO_MD5_DIGESTSIZE] = {
0xac, 0xbd, 0x18, 0xdb, 0x4c, 0xc2, 0xf8, 0x5c,
0xed, 0xef, 0x65, 0x4f, 0xcc, 0xc4, 0xa4, 0xd8,
};
err = memcmp(digest, want_digest, CEPH_CRYPTO_MD5_DIGESTSIZE);
ASSERT_EQ(0, err);
}
TEST(MD5, Restart) {
ceph::crypto::MD5 h;
h.Update((const unsigned char*)"bar", 3);
h.Restart();
h.Update((const unsigned char*)"foo", 3);
unsigned char digest[CEPH_CRYPTO_MD5_DIGESTSIZE];
h.Final(digest);
int err;
unsigned char want_digest[CEPH_CRYPTO_MD5_DIGESTSIZE] = {
0xac, 0xbd, 0x18, 0xdb, 0x4c, 0xc2, 0xf8, 0x5c,
0xed, 0xef, 0x65, 0x4f, 0xcc, 0xc4, 0xa4, 0xd8,
};
err = memcmp(digest, want_digest, CEPH_CRYPTO_MD5_DIGESTSIZE);
ASSERT_EQ(0, err);
}
TEST(HMACSHA1, Simple) {
ceph::crypto::HMACSHA1 h((const unsigned char*)"sekrit", 6);
h.Update((const unsigned char*)"foo", 3);
unsigned char digest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
h.Final(digest);
int err;
unsigned char want_digest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE] = {
0x04, 0xbc, 0x52, 0x66, 0xb6, 0xff, 0xad, 0xad, 0x9d, 0x57,
0xce, 0x13, 0xea, 0x8c, 0xf5, 0x6b, 0xf9, 0x95, 0x2f, 0xd6,
};
err = memcmp(digest, want_digest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
ASSERT_EQ(0, err);
}
TEST(HMACSHA1, MultiUpdate) {
ceph::crypto::HMACSHA1 h((const unsigned char*)"sekrit", 6);
h.Update((const unsigned char*)"", 0);
h.Update((const unsigned char*)"fo", 2);
h.Update((const unsigned char*)"", 0);
h.Update((const unsigned char*)"o", 1);
h.Update((const unsigned char*)"", 0);
unsigned char digest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
h.Final(digest);
int err;
unsigned char want_digest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE] = {
0x04, 0xbc, 0x52, 0x66, 0xb6, 0xff, 0xad, 0xad, 0x9d, 0x57,
0xce, 0x13, 0xea, 0x8c, 0xf5, 0x6b, 0xf9, 0x95, 0x2f, 0xd6,
};
err = memcmp(digest, want_digest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
ASSERT_EQ(0, err);
}
TEST(HMACSHA1, Restart) {
ceph::crypto::HMACSHA1 h((const unsigned char*)"sekrit", 6);
h.Update((const unsigned char*)"bar", 3);
h.Restart();
h.Update((const unsigned char*)"foo", 3);
unsigned char digest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
h.Final(digest);
int err;
unsigned char want_digest[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE] = {
0x04, 0xbc, 0x52, 0x66, 0xb6, 0xff, 0xad, 0xad, 0x9d, 0x57,
0xce, 0x13, 0xea, 0x8c, 0xf5, 0x6b, 0xf9, 0x95, 0x2f, 0xd6,
};
err = memcmp(digest, want_digest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
ASSERT_EQ(0, err);
}
TEST(Digest, SHA1) {
auto digest = [](const bufferlist& bl) {
return ceph::crypto::digest<ceph::crypto::SHA1>(bl);
};
{
bufferlist bl;
sha1_digest_t sha1 = digest(bl);
EXPECT_EQ("da39a3ee5e6b4b0d3255bfef95601890afd80709", sha1.to_str());
}
{
bufferlist bl;
bl.append("");
sha1_digest_t sha1 = digest(bl);
EXPECT_EQ("da39a3ee5e6b4b0d3255bfef95601890afd80709", sha1.to_str());
}
{
bufferlist bl;
bl.append("Hello");
sha1_digest_t sha1 = digest(bl);
EXPECT_EQ("f7ff9e8b7bb2e09b70935a5d785e0cc5d9d0abf0", sha1.to_str());
}
{
bufferlist bl, bl2;
bl.append("Hello");
bl2.append(", world!");
bl.claim_append(bl2);
sha1_digest_t sha1 = digest(bl);
EXPECT_EQ("943a702d06f34599aee1f8da8ef9f7296031d699", sha1.to_str());
bl2.append(" How are you today?");
bl.claim_append(bl2);
sha1 = digest(bl);
EXPECT_EQ("778b5d10e5133aa28fb8de71d35b6999b9a25eb4", sha1.to_str());
}
{
bufferptr p(65536);
memset(p.c_str(), 0, 65536);
bufferlist bl;
bl.append(p);
sha1_digest_t sha1 = digest(bl);
EXPECT_EQ("1adc95bebe9eea8c112d40cd04ab7a8d75c4f961", sha1.to_str());
}
}
TEST(Digest, SHA256) {
auto digest = [](const bufferlist& bl) {
return ceph::crypto::digest<ceph::crypto::SHA256>(bl);
};
{
bufferlist bl;
sha256_digest_t sha256 = digest(bl);
EXPECT_EQ("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", sha256.to_str());
}
{
bufferlist bl;
bl.append("");
sha256_digest_t sha256 = digest(bl);
EXPECT_EQ("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", sha256.to_str());
}
{
bufferlist bl;
bl.append("Hello");
sha256_digest_t sha256 = digest(bl);
EXPECT_EQ("185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969", sha256.to_str());
}
{
bufferlist bl, bl2;
bl.append("Hello");
bl2.append(", world!");
bl.claim_append(bl2);
sha256_digest_t sha256 = digest(bl);
EXPECT_EQ("315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3", sha256.to_str());
bl2.append(" How are you today?");
bl.claim_append(bl2);
sha256 = digest(bl);
EXPECT_EQ("e85f57f8bb018bd4f7beed6f27488cef22b13d5e06e8b8a27cac8b087c2a549e", sha256.to_str());
}
{
bufferptr p(65536);
memset(p.c_str(), 0, 65536);
bufferlist bl;
bl.append(p);
sha256_digest_t sha256 = digest(bl);
EXPECT_EQ("de2f256064a0af797747c2b97505dc0b9f3df0de4f489eac731c23ae9ca9cc31", sha256.to_str());
}
}
TEST(Digest, SHA512) {
auto digest = [](const bufferlist& bl) {
return ceph::crypto::digest<ceph::crypto::SHA512>(bl);
};
{
bufferlist bl;
sha512_digest_t sha512 = digest(bl);
EXPECT_EQ("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", sha512.to_str());
}
{
bufferlist bl;
bl.append("");
sha512_digest_t sha512 = digest(bl);
EXPECT_EQ("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", sha512.to_str());
}
{
bufferlist bl;
bl.append("Hello");
sha512_digest_t sha512 = digest(bl);
EXPECT_EQ("3615f80c9d293ed7402687f94b22d58e529b8cc7916f8fac7fddf7fbd5af4cf777d3d795a7a00a16bf7e7f3fb9561ee9baae480da9fe7a18769e71886b03f315", sha512.to_str());
}
{
bufferlist bl, bl2;
bl.append("Hello");
bl2.append(", world!");
bl.claim_append(bl2);
sha512_digest_t sha512 = digest(bl);
EXPECT_EQ("c1527cd893c124773d811911970c8fe6e857d6df5dc9226bd8a160614c0cd963a4ddea2b94bb7d36021ef9d865d5cea294a82dd49a0bb269f51f6e7a57f79421", sha512.to_str());
bl2.append(" How are you today?");
bl.claim_append(bl2);
sha512 = digest(bl);
EXPECT_EQ("7d50e299496754f9a0d158e018d4b733f2ef51c487b43b50719ffdabe3c3da5a347029741056887b4ffa2ddd0aa9e0dd358b8ed9da9a4f3455f44896fc8e5395", sha512.to_str());
}
{
bufferptr p(65536);
memset(p.c_str(), 0, 65536);
bufferlist bl;
bl.append(p);
sha512_digest_t sha512 = digest(bl);
EXPECT_EQ("73e4153936dab198397b74ee9efc26093dda721eaab2f8d92786891153b45b04265a161b169c988edb0db2c53124607b6eaaa816559c5ce54f3dbc9fa6a7a4b2", sha512.to_str());
}
}
class ForkDeathTest : public ::testing::Test {
protected:
void SetUp() override {
// shutdown NSS so it can be reinitialized after the fork
// some data structures used by NSPR are only initialized once, and they
// will be cleaned up with ceph::crypto::shutdown(false), so we need to
// keep them around after fork.
ceph::crypto::shutdown(true);
}
void TearDown() override {
// undo the NSS shutdown we did in the parent process, after the
// test is done
ceph::crypto::init();
}
};
void do_simple_crypto() {
// ensure that the shutdown/fork/init sequence results in a working
// NSS crypto library; this function is run in the child, after the
// fork, and if you comment out the ceph::crypto::init, or if the
// trick were to fail, you would see this ending in an assert and
// not exit status 0
ceph::crypto::init();
ceph::crypto::MD5 h;
h.Update((const unsigned char*)"foo", 3);
unsigned char digest[CEPH_CRYPTO_MD5_DIGESTSIZE];
h.Final(digest);
exit(0);
}
#if GTEST_HAS_DEATH_TEST && !defined(_WIN32)
TEST_F(ForkDeathTest, MD5) {
ASSERT_EXIT(do_simple_crypto(), ::testing::ExitedWithCode(0), "^$");
}
#endif // GTEST_HAS_DEATH_TEST && !defined(_WIN32)
int main(int argc, char **argv) {
std::vector<const char*> args(argv, argv + argc);
auto cct = global_init(NULL, args,
CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 9,505 | 32.121951 | 163 |
cc
|
null |
ceph-main/src/test/confutils.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/ConfUtils.h"
#include "common/config_proxy.h"
#include "common/errno.h"
#include "gtest/gtest.h"
#include "include/buffer.h"
#include <errno.h>
#include <filesystem>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <stdint.h>
#include <sys/stat.h>
#include <sys/types.h>
namespace fs = std::filesystem;
using namespace std;
using ceph::bufferlist;
using std::cerr;
using std::ostringstream;
#define MAX_FILES_TO_DELETE 1000UL
static size_t config_idx = 0;
static size_t unlink_idx = 0;
static char *to_unlink[MAX_FILES_TO_DELETE];
static std::string get_temp_dir()
{
static std::string temp_dir;
if (temp_dir.empty()) {
const char *tmpdir = getenv("TMPDIR");
if (!tmpdir)
tmpdir = "/tmp";
srand(time(NULL));
ostringstream oss;
oss << tmpdir << "/confutils_test_dir." << rand() << "." << getpid();
umask(022);
if (!fs::exists(oss.str())) {
std::error_code ec;
if (!fs::create_directory(oss.str(), ec)) {
cerr << "failed to create temp directory '" << temp_dir << "' "
<< ec.message() << std::endl;
return "";
}
fs::permissions(oss.str(), fs::perms::sticky_bit | fs::perms::all);
}
temp_dir = oss.str();
}
return temp_dir;
}
static void unlink_all(void)
{
for (size_t i = 0; i < unlink_idx; ++i) {
unlink(to_unlink[i]);
}
for (size_t i = 0; i < unlink_idx; ++i) {
free(to_unlink[i]);
}
rmdir(get_temp_dir().c_str());
}
static int create_tempfile(const std::string &fname, const char *text)
{
FILE *fp = fopen(fname.c_str(), "w");
if (!fp) {
int err = errno;
cerr << "Failed to write file '" << fname << "' to temp directory '"
<< get_temp_dir() << "'. " << cpp_strerror(err) << std::endl;
return err;
}
std::shared_ptr<FILE> fpp(fp, fclose);
if (unlink_idx >= MAX_FILES_TO_DELETE)
return -ENOBUFS;
if (unlink_idx == 0) {
memset(to_unlink, 0, sizeof(to_unlink));
atexit(unlink_all);
}
to_unlink[unlink_idx++] = strdup(fname.c_str());
size_t strlen_text = strlen(text);
size_t res = fwrite(text, 1, strlen_text, fp);
if (res != strlen_text) {
int err = errno;
cerr << "fwrite error while writing to " << fname
<< ": " << cpp_strerror(err) << std::endl;
return err;
}
return 0;
}
static std::string next_tempfile(const char *text)
{
ostringstream oss;
std::string temp_dir(get_temp_dir());
if (temp_dir.empty())
return "";
oss << temp_dir << "/test_config." << config_idx++ << ".config";
int ret = create_tempfile(oss.str(), text);
if (ret)
return "";
return oss.str();
}
const char * const trivial_conf_1 = "";
const char * const trivial_conf_2 = "log dir = foobar";
const char * const trivial_conf_3 = "log dir = barfoo\n";
const char * const trivial_conf_4 = "log dir = \"barbaz\"\n";
const char * const simple_conf_1 = "\
; here's a comment\n\
[global]\n\
keyring = .my_ceph_keyring\n\
\n\
[mds]\n\
log dir = out\n\
log per instance = true\n\
log sym history = 100\n\
profiling logger = true\n\
profiling logger dir = wowsers\n\
chdir = ""\n\
pid file = out/$name.pid\n\
\n\
mds debug frag = true\n\
[osd]\n\
pid file = out/$name.pid\n\
osd scrub load threshold = 5.0\n\
\n\
lockdep = 1\n\
[osd0]\n\
osd data = dev/osd0\n\
osd journal size = 100\n\
[mds.a]\n\
[mds.b]\n\
[mds.c]\n\
";
// we can add whitespace at odd locations and it will get stripped out.
const char * const simple_conf_2 = "\
[mds.a]\n\
log dir = special_mds_a\n\
[mds]\n\
log sym history = 100\n\
log dir = out # after a comment, anything # can ### happen ;;; right?\n\
log per instance = true\n\
profiling logger = true\n\
profiling logger dir = log\n\
chdir = ""\n\
pid file\t=\tfoo2\n\
[osd0]\n\
keyring = osd_keyring ; osd's keyring\n\
\n\
\n\
[global]\n\
# I like pound signs as comment markers.\n\
; Do you like pound signs as comment markers?\n\
keyring = shenanigans ; The keyring of a leprechaun\n\
\n\
# Let's just have a line with a lot of whitespace and nothing else.\n\
\n\
lockdep = 1\n\
";
// test line-combining
const char * const conf3 = "\
[global]\n\
log file = /quite/a/long/path\\\n\
/for/a/log/file\n\
pid file = \\\n\
spork\\\n\
\n\
[mon] #nothing here \n\
";
const char * const escaping_conf_1 = "\
[global]\n\
log file = the \"scare quotes\"\n\
pid file = a \\\n\
pid file\n\
[mon]\n\
keyring = \"nested \\\"quotes\\\"\"\n\
";
const char * const escaping_conf_2 = "\
[apple \\]\\[]\n\
log file = floppy disk\n\
[mon]\n\
keyring = \"backslash\\\\\"\n\
";
// illegal because it contains an invalid utf8 sequence.
const char illegal_conf1[] = "\
[global]\n\
log file = foo\n\
pid file = invalid-utf-\xe2\x28\xa1\n\
[osd0]\n\
keyring = osd_keyring ; osd's keyring\n\
";
// illegal because it contains a malformed section header.
const char illegal_conf2[] = "\
[global\n\
log file = foo\n\
[osd0]\n\
keyring = osd_keyring ; osd's keyring\n\
";
// illegal because it contains a line that doesn't parse
const char illegal_conf3[] = "\
[global]\n\
who_what_where\n\
[osd0]\n\
keyring = osd_keyring ; osd's keyring\n\
";
// illegal because it has unterminated quotes
const char illegal_conf4[] = "\
[global]\n\
keyring = \"unterminated quoted string\n\
[osd0]\n\
keyring = osd_keyring ; osd's keyring\n\
";
const char override_config_1[] = "\
[global]\n\
log file = global_log\n\
[mds]\n\
log file = mds_log\n\
[osd]\n\
log file = osd_log\n\
[osd.0]\n\
log file = osd0_log\n\
";
const char dup_key_config_1[] = "\
[mds.a]\n\
log_file = 1\n\
log_file = 3\n\
";
TEST(ConfUtils, ParseFiles0) {
std::string val;
{
std::ostringstream err;
std::string trivial_conf_1_f(next_tempfile(trivial_conf_1));
ConfFile cf1;
ASSERT_EQ(cf1.parse_file(trivial_conf_1_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
}
{
std::ostringstream err;
std::string trivial_conf_2_f(next_tempfile(trivial_conf_2));
ConfFile cf2;
ASSERT_EQ(cf2.parse_file(trivial_conf_2_f.c_str(), &err), -EINVAL);
ASSERT_GT(err.tellp(), 0U);
}
{
std::ostringstream err;
bufferlist bl3;
bl3.append(trivial_conf_3, strlen(trivial_conf_3));
ConfFile cf3;
ASSERT_EQ(cf3.parse_bufferlist(&bl3, &err), 0);
ASSERT_EQ(err.tellp(), 0U);
ASSERT_EQ(cf3.read("global", "log dir", val), 0);
ASSERT_EQ(val, "barfoo");
}
{
std::ostringstream err;
std::string trivial_conf_4_f(next_tempfile(trivial_conf_4));
ConfFile cf4;
ASSERT_EQ(cf4.parse_file(trivial_conf_4_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
ASSERT_EQ(cf4.read("global", "log dir", val), 0);
ASSERT_EQ(val, "barbaz");
}
}
TEST(ConfUtils, ParseFiles1) {
std::ostringstream err;
std::string simple_conf_1_f(next_tempfile(simple_conf_1));
ConfFile cf1;
ASSERT_EQ(cf1.parse_file(simple_conf_1_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
std::string simple_conf_2_f(next_tempfile(simple_conf_1));
ConfFile cf2;
ASSERT_EQ(cf2.parse_file(simple_conf_2_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
bufferlist bl3;
bl3.append(simple_conf_1, strlen(simple_conf_1));
ConfFile cf3;
ASSERT_EQ(cf3.parse_bufferlist(&bl3, &err), 0);
ASSERT_EQ(err.tellp(), 0U);
bufferlist bl4;
bl4.append(simple_conf_2, strlen(simple_conf_2));
ConfFile cf4;
ASSERT_EQ(cf4.parse_bufferlist(&bl4, &err), 0);
ASSERT_EQ(err.tellp(), 0U);
}
TEST(ConfUtils, ReadFiles1) {
std::ostringstream err;
std::string simple_conf_1_f(next_tempfile(simple_conf_1));
ConfFile cf1;
ASSERT_EQ(cf1.parse_file(simple_conf_1_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
std::string val;
ASSERT_EQ(cf1.read("global", "keyring", val), 0);
ASSERT_EQ(val, ".my_ceph_keyring");
ASSERT_EQ(cf1.read("mds", "profiling logger dir", val), 0);
ASSERT_EQ(val, "wowsers");
ASSERT_EQ(cf1.read("mds", "something that does not exist", val), -ENOENT);
// exists in mds section, but not in global
ASSERT_EQ(cf1.read("global", "profiling logger dir", val), -ENOENT);
bufferlist bl2;
bl2.append(simple_conf_2, strlen(simple_conf_2));
ConfFile cf2;
ASSERT_EQ(cf2.parse_bufferlist(&bl2, &err), 0);
ASSERT_EQ(err.tellp(), 0U);
ASSERT_EQ(cf2.read("osd0", "keyring", val), 0);
ASSERT_EQ(val, "osd_keyring");
ASSERT_EQ(cf2.read("mds", "pid file", val), 0);
ASSERT_EQ(val, "foo2");
ASSERT_EQ(cf2.read("nonesuch", "keyring", val), -ENOENT);
}
TEST(ConfUtils, ReadFiles2) {
std::ostringstream err;
std::string conf3_f(next_tempfile(conf3));
ConfFile cf1;
std::string val;
ASSERT_EQ(cf1.parse_file(conf3_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
ASSERT_EQ(cf1.read("global", "log file", val), 0);
ASSERT_EQ(val, "/quite/a/long/path/for/a/log/file");
ASSERT_EQ(cf1.read("global", "pid file", val), 0);
ASSERT_EQ(val, "spork");
}
TEST(ConfUtils, IllegalFiles) {
{
std::ostringstream err;
ConfFile cf1;
std::string illegal_conf1_f(next_tempfile(illegal_conf1));
ASSERT_EQ(cf1.parse_file(illegal_conf1_f.c_str(), &err), -EINVAL);
ASSERT_GT(err.tellp(), 0U);
}
{
std::ostringstream err;
bufferlist bl2;
bl2.append(illegal_conf2, strlen(illegal_conf2));
ConfFile cf2;
ASSERT_EQ(cf2.parse_bufferlist(&bl2, &err), -EINVAL);
ASSERT_GT(err.tellp(), 0U);
}
{
std::ostringstream err;
std::string illegal_conf3_f(next_tempfile(illegal_conf3));
ConfFile cf3;
ASSERT_EQ(cf3.parse_file(illegal_conf3_f.c_str(), &err), -EINVAL);
ASSERT_GT(err.tellp(), 0U);
}
{
std::ostringstream err;
std::string illegal_conf4_f(next_tempfile(illegal_conf4));
ConfFile cf4;
ASSERT_EQ(cf4.parse_file(illegal_conf4_f.c_str(), &err), -EINVAL);
ASSERT_GT(err.tellp(), 0U);
}
}
TEST(ConfUtils, EscapingFiles) {
std::ostringstream err;
std::string escaping_conf_1_f(next_tempfile(escaping_conf_1));
ConfFile cf1;
std::string val;
ASSERT_EQ(cf1.parse_file(escaping_conf_1_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
ASSERT_EQ(cf1.read("global", "log file", val), 0);
ASSERT_EQ(val, "the \"scare quotes\"");
ASSERT_EQ(cf1.read("global", "pid file", val), 0);
ASSERT_EQ(val, "a pid file");
ASSERT_EQ(cf1.read("mon", "keyring", val), 0);
ASSERT_EQ(val, "nested \"quotes\"");
std::string escaping_conf_2_f(next_tempfile(escaping_conf_2));
ConfFile cf2;
ASSERT_EQ(cf2.parse_file(escaping_conf_2_f.c_str(), &err), 0);
ASSERT_EQ(err.tellp(), 0U);
ASSERT_EQ(cf2.read("apple ][", "log file", val), 0);
ASSERT_EQ(val, "floppy disk");
ASSERT_EQ(cf2.read("mon", "keyring", val), 0);
ASSERT_EQ(val, "backslash\\");
}
TEST(ConfUtils, Overrides) {
ConfigProxy conf{false};
std::ostringstream warn;
std::string override_conf_1_f(next_tempfile(override_config_1));
conf->name.set(CEPH_ENTITY_TYPE_MON, "0");
conf.parse_config_files(override_conf_1_f.c_str(), &warn, 0);
ASSERT_FALSE(conf.has_parse_error());
ASSERT_EQ(conf->log_file, "global_log");
conf->name.set(CEPH_ENTITY_TYPE_MDS, "a");
conf.parse_config_files(override_conf_1_f.c_str(), &warn, 0);
ASSERT_FALSE(conf.has_parse_error());
ASSERT_EQ(conf->log_file, "mds_log");
conf->name.set(CEPH_ENTITY_TYPE_OSD, "0");
conf.parse_config_files(override_conf_1_f.c_str(), &warn, 0);
ASSERT_FALSE(conf.has_parse_error());
ASSERT_EQ(conf->log_file, "osd0_log");
}
TEST(ConfUtils, DupKey) {
ConfigProxy conf{false};
std::ostringstream warn;
std::string dup_key_config_f(next_tempfile(dup_key_config_1));
conf->name.set(CEPH_ENTITY_TYPE_MDS, "a");
conf.parse_config_files(dup_key_config_f.c_str(), &warn, 0);
ASSERT_FALSE(conf.has_parse_error());
ASSERT_EQ(conf->log_file, string("3"));
}
| 12,434 | 26.091503 | 76 |
cc
|
null |
ceph-main/src/test/coverage.sh
|
#!/bin/sh
set -e
usage () {
printf '%s: usage: %s [-d srcdir] [-o output_basename] COMMAND [ARGS..]\n' "$(basename "$0")" "$(basename "$0")" 1>&2
exit 1
}
OUTPUT_BASENAME=coverage
SRCDIR=.
while getopts "d:o:h" flag
do
case $flag in
d) SRCDIR=$OPTARG;;
o) OUTPUT_BASENAME=$OPTARG;;
*) usage;;
esac
done
shift $(($OPTIND - 1))
lcov -d $SRCDIR -z > /dev/null 2>&1
lcov -d $SRCDIR -c -i -o "${OUTPUT_BASENAME}_base_full.lcov" > /dev/null 2>&1
"$@"
lcov -d $SRCDIR -c -o "${OUTPUT_BASENAME}_tested_full.lcov" > /dev/null 2>&1
lcov -r "${OUTPUT_BASENAME}_base_full.lcov" /usr/include\* -o "${OUTPUT_BASENAME}_base.lcov" > /dev/null 2>&1
lcov -r "${OUTPUT_BASENAME}_tested_full.lcov" /usr/include\* -o "${OUTPUT_BASENAME}_tested.lcov" > /dev/null 2>&1
lcov -a "${OUTPUT_BASENAME}_base.lcov" -a "${OUTPUT_BASENAME}_tested.lcov" -o "${OUTPUT_BASENAME}.lcov" | tail -n 3
| 900 | 29.033333 | 123 |
sh
|
null |
ceph-main/src/test/crypto.cc
|
#include <errno.h>
#include <time.h>
#include <boost/container/small_vector.hpp>
#include "gtest/gtest.h"
#include "include/types.h"
#include "auth/Crypto.h"
#include "common/Clock.h"
#include "common/ceph_crypto.h"
#include "common/ceph_context.h"
#include "global/global_context.h"
using namespace std;
class CryptoEnvironment: public ::testing::Environment {
public:
void SetUp() override {
ceph::crypto::init();
}
};
TEST(AES, ValidateSecret) {
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
int l;
for (l=0; l<16; l++) {
bufferptr bp(l);
int err;
err = h->validate_secret(bp);
EXPECT_EQ(-EINVAL, err);
}
for (l=16; l<50; l++) {
bufferptr bp(l);
int err;
err = h->validate_secret(bp);
EXPECT_EQ(0, err);
}
}
TEST(AES, Encrypt) {
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
char secret_s[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
};
bufferptr secret(secret_s, sizeof(secret_s));
unsigned char plaintext_s[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
};
bufferlist plaintext;
plaintext.append((char *)plaintext_s, sizeof(plaintext_s));
bufferlist cipher;
std::string error;
CryptoKeyHandler *kh = h->get_key_handler(secret, error);
int r = kh->encrypt(plaintext, cipher, &error);
ASSERT_EQ(r, 0);
ASSERT_EQ(error, "");
unsigned char want_cipher[] = {
0xb3, 0x8f, 0x5b, 0xc9, 0x35, 0x4c, 0xf8, 0xc6,
0x13, 0x15, 0x66, 0x6f, 0x37, 0xd7, 0x79, 0x3a,
0x11, 0x90, 0x7b, 0xe9, 0xd8, 0x3c, 0x35, 0x70,
0x58, 0x7b, 0x97, 0x9b, 0x03, 0xd2, 0xa5, 0x01,
};
char cipher_s[sizeof(want_cipher)];
ASSERT_EQ(sizeof(cipher_s), cipher.length());
cipher.cbegin().copy(sizeof(cipher_s), &cipher_s[0]);
int err;
err = memcmp(cipher_s, want_cipher, sizeof(want_cipher));
ASSERT_EQ(0, err);
delete kh;
}
TEST(AES, EncryptNoBl) {
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
char secret_s[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
};
bufferptr secret(secret_s, sizeof(secret_s));
const unsigned char plaintext[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
};
std::string error;
std::unique_ptr<CryptoKeyHandler> kh(h->get_key_handler(secret, error));
const CryptoKey::in_slice_t plain_slice { sizeof(plaintext), plaintext };
// we need to deduce size first
const CryptoKey::out_slice_t probe_slice { 0, nullptr };
const auto needed = kh->encrypt(plain_slice, probe_slice);
ASSERT_GE(needed, plain_slice.length);
boost::container::small_vector<
// FIXME?
//unsigned char, sizeof(plaintext) + kh->get_block_size()> buf;
unsigned char, sizeof(plaintext) + 16> buf(needed);
const CryptoKey::out_slice_t cipher_slice { needed, buf.data() };
const auto cipher_size = kh->encrypt(plain_slice, cipher_slice);
ASSERT_EQ(cipher_size, needed);
const unsigned char want_cipher[] = {
0xb3, 0x8f, 0x5b, 0xc9, 0x35, 0x4c, 0xf8, 0xc6,
0x13, 0x15, 0x66, 0x6f, 0x37, 0xd7, 0x79, 0x3a,
0x11, 0x90, 0x7b, 0xe9, 0xd8, 0x3c, 0x35, 0x70,
0x58, 0x7b, 0x97, 0x9b, 0x03, 0xd2, 0xa5, 0x01,
};
ASSERT_EQ(sizeof(want_cipher), cipher_size);
const int err = memcmp(buf.data(), want_cipher, sizeof(want_cipher));
ASSERT_EQ(0, err);
}
TEST(AES, Decrypt) {
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
char secret_s[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
};
bufferptr secret(secret_s, sizeof(secret_s));
unsigned char cipher_s[] = {
0xb3, 0x8f, 0x5b, 0xc9, 0x35, 0x4c, 0xf8, 0xc6,
0x13, 0x15, 0x66, 0x6f, 0x37, 0xd7, 0x79, 0x3a,
0x11, 0x90, 0x7b, 0xe9, 0xd8, 0x3c, 0x35, 0x70,
0x58, 0x7b, 0x97, 0x9b, 0x03, 0xd2, 0xa5, 0x01,
};
bufferlist cipher;
cipher.append((char *)cipher_s, sizeof(cipher_s));
unsigned char want_plaintext[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
};
char plaintext_s[sizeof(want_plaintext)];
std::string error;
bufferlist plaintext;
CryptoKeyHandler *kh = h->get_key_handler(secret, error);
int r = kh->decrypt(cipher, plaintext, &error);
ASSERT_EQ(r, 0);
ASSERT_EQ(error, "");
ASSERT_EQ(sizeof(plaintext_s), plaintext.length());
plaintext.cbegin().copy(sizeof(plaintext_s), &plaintext_s[0]);
int err;
err = memcmp(plaintext_s, want_plaintext, sizeof(want_plaintext));
ASSERT_EQ(0, err);
delete kh;
}
TEST(AES, DecryptNoBl) {
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
const char secret_s[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
};
bufferptr secret(secret_s, sizeof(secret_s));
const unsigned char ciphertext[] = {
0xb3, 0x8f, 0x5b, 0xc9, 0x35, 0x4c, 0xf8, 0xc6,
0x13, 0x15, 0x66, 0x6f, 0x37, 0xd7, 0x79, 0x3a,
0x11, 0x90, 0x7b, 0xe9, 0xd8, 0x3c, 0x35, 0x70,
0x58, 0x7b, 0x97, 0x9b, 0x03, 0xd2, 0xa5, 0x01,
};
const unsigned char want_plaintext[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
};
constexpr static std::size_t plain_buf_size = \
CryptoKey::get_max_outbuf_size(sizeof(want_plaintext));
unsigned char plaintext[plain_buf_size];
std::string error;
std::unique_ptr<CryptoKeyHandler> kh(h->get_key_handler(secret, error));
CryptoKey::in_slice_t cipher_slice { sizeof(ciphertext), ciphertext };
CryptoKey::out_slice_t plain_slice { sizeof(plaintext), plaintext };
const auto plain_size = kh->decrypt(cipher_slice, plain_slice);
ASSERT_EQ(plain_size, sizeof(want_plaintext));
const int err = memcmp(plaintext, want_plaintext, sizeof(plain_size));
ASSERT_EQ(0, err);
}
template <std::size_t TextSizeV>
static void aes_loop_cephx() {
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
CryptoRandom random;
bufferptr secret(16);
random.get_bytes(secret.c_str(), secret.length());
std::string error;
std::unique_ptr<CryptoKeyHandler> kh(h->get_key_handler(secret, error));
unsigned char plaintext[TextSizeV];
random.get_bytes(reinterpret_cast<char*>(plaintext), sizeof(plaintext));
const CryptoKey::in_slice_t plain_slice { sizeof(plaintext), plaintext };
// we need to deduce size first
const CryptoKey::out_slice_t probe_slice { 0, nullptr };
const auto needed = kh->encrypt(plain_slice, probe_slice);
ASSERT_GE(needed, plain_slice.length);
boost::container::small_vector<
// FIXME?
//unsigned char, sizeof(plaintext) + kh->get_block_size()> buf;
unsigned char, sizeof(plaintext) + 16> buf(needed);
std::size_t cipher_size;
for (std::size_t i = 0; i < 1000000; i++) {
const CryptoKey::out_slice_t cipher_slice { needed, buf.data() };
cipher_size = kh->encrypt(plain_slice, cipher_slice);
ASSERT_EQ(cipher_size, needed);
}
}
// These magics reflects Cephx's signature size. Please consult
// CephxSessionHandler::_calc_signature() for more details.
TEST(AES, LoopCephx) {
aes_loop_cephx<29>();
}
TEST(AES, LoopCephxV2) {
aes_loop_cephx<32>();
}
static void aes_loop(const std::size_t text_size) {
CryptoRandom random;
bufferptr secret(16);
random.get_bytes(secret.c_str(), secret.length());
bufferptr orig_plaintext(text_size);
random.get_bytes(orig_plaintext.c_str(), orig_plaintext.length());
bufferlist plaintext;
plaintext.append(orig_plaintext.c_str(), orig_plaintext.length());
for (int i=0; i<10000; i++) {
bufferlist cipher;
{
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
std::string error;
CryptoKeyHandler *kh = h->get_key_handler(secret, error);
int r = kh->encrypt(plaintext, cipher, &error);
ASSERT_EQ(r, 0);
ASSERT_EQ(error, "");
delete kh;
}
plaintext.clear();
{
CryptoHandler *h = g_ceph_context->get_crypto_handler(CEPH_CRYPTO_AES);
std::string error;
CryptoKeyHandler *ckh = h->get_key_handler(secret, error);
int r = ckh->decrypt(cipher, plaintext, &error);
ASSERT_EQ(r, 0);
ASSERT_EQ(error, "");
delete ckh;
}
}
bufferlist orig;
orig.append(orig_plaintext);
ASSERT_EQ(orig, plaintext);
}
TEST(AES, Loop) {
aes_loop(256);
}
// These magics reflects Cephx's signature size. Please consult
// CephxSessionHandler::_calc_signature() for more details.
TEST(AES, Loop_29) {
aes_loop(29);
}
TEST(AES, Loop_32) {
aes_loop(32);
}
void aes_loopkey(const std::size_t text_size) {
CryptoRandom random;
bufferptr k(16);
random.get_bytes(k.c_str(), k.length());
CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(), k);
bufferlist data;
bufferptr r(text_size);
random.get_bytes(r.c_str(), r.length());
data.append(r);
utime_t start = ceph_clock_now();
int n = 100000;
for (int i=0; i<n; ++i) {
bufferlist encoded;
string error;
int r = key.encrypt(g_ceph_context, data, encoded, &error);
ASSERT_EQ(r, 0);
}
utime_t end = ceph_clock_now();
utime_t dur = end - start;
cout << n << " encoded in " << dur << std::endl;
}
TEST(AES, LoopKey) {
aes_loopkey(128);
}
// These magics reflects Cephx's signature size. Please consult
// CephxSessionHandler::_calc_signature() for more details.
TEST(AES, LoopKey_29) {
aes_loopkey(29);
}
TEST(AES, LoopKey_32) {
aes_loopkey(32);
}
| 9,684 | 27.236152 | 77 |
cc
|
null |
ceph-main/src/test/crypto_init.cc
|
#include <errno.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include "include/types.h"
#include "common/code_environment.h"
#include "global/global_context.h"
#include "global/global_init.h"
#include "include/msgr.h"
#include "gtest/gtest.h"
#include "auth/Crypto.h"
#include "common/ceph_crypto.h"
// TODO: ensure OpenSSL init
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 471 | 20.454545 | 41 |
cc
|
null |
ceph-main/src/test/cxx11_client.cc
|
#include "include/buffer.h"
// We might want to include here all our public headers.
// Not any file residing in src/include has this status.
int main() {}
| 158 | 21.714286 | 56 |
cc
|
null |
ceph-main/src/test/daemon_config.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "global/global_context.h"
#include "include/cephfs/libcephfs.h"
#include "include/rados/librados.h"
#include <errno.h>
#include <sstream>
#include <string>
#include <string.h>
#include <boost/lexical_cast.hpp>
using namespace std;
TEST(DaemonConfig, SimpleSet) {
int ret;
ret = g_ceph_context->_conf.set_val("log_graylog_port", "21");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[128];
memset(buf, 0, sizeof(buf));
char *tmp = buf;
ret = g_ceph_context->_conf.get_val("log_graylog_port", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("21"), string(buf));
g_ceph_context->_conf.rm_val("log_graylog_port");
}
TEST(DaemonConfig, Substitution) {
int ret;
g_conf()._clear_safe_to_start_threads();
ret = g_ceph_context->_conf.set_val("host", "foo");
ASSERT_EQ(0, ret);
ret = g_ceph_context->_conf.set_val("public_network", "bar$host.baz");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[128];
memset(buf, 0, sizeof(buf));
char *tmp = buf;
ret = g_ceph_context->_conf.get_val("public_network", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("barfoo.baz"), string(buf));
}
TEST(DaemonConfig, SubstitutionTrailing) {
int ret;
g_conf()._clear_safe_to_start_threads();
ret = g_ceph_context->_conf.set_val("host", "foo");
ASSERT_EQ(0, ret);
ret = g_ceph_context->_conf.set_val("public_network", "bar$host");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[128];
memset(buf, 0, sizeof(buf));
char *tmp = buf;
ret = g_ceph_context->_conf.get_val("public_network", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("barfoo"), string(buf));
}
TEST(DaemonConfig, SubstitutionBraces) {
int ret;
g_conf()._clear_safe_to_start_threads();
ret = g_ceph_context->_conf.set_val("host", "foo");
ASSERT_EQ(0, ret);
ret = g_ceph_context->_conf.set_val("public_network", "bar${host}baz");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[128];
memset(buf, 0, sizeof(buf));
char *tmp = buf;
ret = g_ceph_context->_conf.get_val("public_network", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("barfoobaz"), string(buf));
}
TEST(DaemonConfig, SubstitutionBracesTrailing) {
int ret;
g_conf()._clear_safe_to_start_threads();
ret = g_ceph_context->_conf.set_val("host", "foo");
ASSERT_EQ(0, ret);
ret = g_ceph_context->_conf.set_val("public_network", "bar${host}");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[128];
memset(buf, 0, sizeof(buf));
char *tmp = buf;
ret = g_ceph_context->_conf.get_val("public_network", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("barfoo"), string(buf));
}
// config: variable substitution happen only once http://tracker.ceph.com/issues/7103
TEST(DaemonConfig, SubstitutionMultiple) {
int ret;
ret = g_ceph_context->_conf.set_val("mon_host", "localhost");
ASSERT_EQ(0, ret);
ret = g_ceph_context->_conf.set_val("keyring", "$mon_host/$cluster.keyring,$mon_host/$cluster.mon.keyring");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[512];
memset(buf, 0, sizeof(buf));
char *tmp = buf;
ret = g_ceph_context->_conf.get_val("keyring", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("localhost/ceph.keyring,localhost/ceph.mon.keyring"), tmp);
ASSERT_TRUE(strchr(buf, '$') == NULL);
}
TEST(DaemonConfig, ArgV) {
g_conf()._clear_safe_to_start_threads();
int ret;
const char *argv[] = { "foo", "--log-graylog-port", "22",
"--key", "my-key", NULL };
size_t argc = (sizeof(argv) / sizeof(argv[0])) - 1;
auto args = argv_to_vec(argc, argv);
g_ceph_context->_conf.parse_argv(args);
g_ceph_context->_conf.apply_changes(nullptr);
char buf[128];
char *tmp = buf;
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("key", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("my-key"), string(buf));
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_graylog_port", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("22"), string(buf));
g_conf().set_safe_to_start_threads();
}
TEST(DaemonConfig, InjectArgs) {
int ret;
std::string injection("--log-graylog-port 56 --log_max_new 42");
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(0, ret);
char buf[128];
char *tmp = buf;
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_max_new", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("42"), string(buf));
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_graylog_port", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("56"), string(buf));
injection = "--log-graylog-port 57";
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(0, ret);
ret = g_ceph_context->_conf.get_val("log_graylog_port", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("57"), string(buf));
}
TEST(DaemonConfig, InjectArgsReject) {
int ret;
char buf[128];
char *tmp = buf;
char buf2[128];
char *tmp2 = buf2;
// We should complain about the garbage in the input
std::string injection("--random-garbage-in-injectargs 26 --log-graylog-port 28");
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(-EINVAL, ret);
// But, debug should still be set...
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_graylog_port", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("28"), string(buf));
// What's the current value of osd_data?
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("osd_data", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
// Injectargs shouldn't let us change this, since it is a string-valued
// variable and there isn't an observer for it.
std::string injection2("--osd_data /tmp/some-other-directory --log-graylog-port 4");
ret = g_ceph_context->_conf.injectargs(injection2, &cout);
ASSERT_EQ(-EPERM, ret);
// It should be unchanged.
memset(buf2, 0, sizeof(buf2));
ret = g_ceph_context->_conf.get_val("osd_data", &tmp2, sizeof(buf2));
ASSERT_EQ(0, ret);
ASSERT_EQ(string(buf), string(buf2));
// We should complain about the missing arguments.
std::string injection3("--log-graylog-port 28 --debug_ms");
ret = g_ceph_context->_conf.injectargs(injection3, &cout);
ASSERT_EQ(-EINVAL, ret);
}
TEST(DaemonConfig, InjectArgsBooleans) {
int ret;
char buf[128];
char *tmp = buf;
// Change log_to_syslog
std::string injection("--log_to_syslog --log-graylog-port 28");
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(0, ret);
// log_to_syslog should be set...
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_to_syslog", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("true"), string(buf));
// Turn off log_to_syslog
injection = "--log_to_syslog=false --log-graylog-port 28";
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(0, ret);
// log_to_syslog should be cleared...
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_to_syslog", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("false"), string(buf));
// Turn on log_to_syslog
injection = "--log-graylog-port=1 --log_to_syslog=true --log_max_new 40";
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(0, ret);
// log_to_syslog should be set...
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_to_syslog", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("true"), string(buf));
// parse error
injection = "--log-graylog-port 1 --log_to_syslog=falsey --log_max_new 42";
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(-EINVAL, ret);
// log_to_syslog should still be set...
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_to_syslog", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("true"), string(buf));
// debug-ms should still become 42...
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_max_new", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("42"), string(buf));
}
TEST(DaemonConfig, InjectArgsLogfile) {
int ret;
char tmpfile[PATH_MAX];
const char *tmpdir = getenv("TMPDIR");
if (!tmpdir)
tmpdir = "/tmp";
snprintf(tmpfile, sizeof(tmpfile), "%s/daemon_config_test.%d",
tmpdir, getpid());
std::string injection("--log_file ");
injection += tmpfile;
// We're allowed to change log_file because there is an observer.
ret = g_ceph_context->_conf.injectargs(injection, &cout);
ASSERT_EQ(0, ret);
// It should have taken effect.
char buf[128];
char *tmp = buf;
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("log_file", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string(buf), string(tmpfile));
// The logfile should exist.
ASSERT_EQ(0, access(tmpfile, R_OK));
// Let's turn off the logfile.
ret = g_ceph_context->_conf.set_val("log_file", "");
ASSERT_EQ(0, ret);
g_ceph_context->_conf.apply_changes(nullptr);
ret = g_ceph_context->_conf.get_val("log_file", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string(""), string(buf));
// Clean up the garbage
unlink(tmpfile);
}
TEST(DaemonConfig, ThreadSafety1) {
int ret;
// Verify that we can't change this, since safe_to_start_threads has
// been set.
ret = g_ceph_context->_conf.set_val("osd_data", "");
ASSERT_EQ(-EPERM, ret);
g_conf()._clear_safe_to_start_threads();
// Ok, now we can change this. Since this is just a test, and there are no
// OSD threads running, we know changing osd_data won't actually blow up the
// world.
ret = g_ceph_context->_conf.set_val("osd_data", "/tmp/crazydata");
ASSERT_EQ(0, ret);
char buf[128];
char *tmp = buf;
memset(buf, 0, sizeof(buf));
ret = g_ceph_context->_conf.get_val("osd_data", &tmp, sizeof(buf));
ASSERT_EQ(0, ret);
ASSERT_EQ(string("/tmp/crazydata"), string(buf));
g_conf()._clear_safe_to_start_threads();
ASSERT_EQ(0, ret);
}
TEST(DaemonConfig, InvalidIntegers) {
{
int ret = g_ceph_context->_conf.set_val("log_graylog_port", "rhubarb");
ASSERT_EQ(-EINVAL, ret);
}
{
int64_t max = std::numeric_limits<int64_t>::max();
string str = boost::lexical_cast<string>(max);
str = str + "999"; // some extra digits to take us out of bounds
int ret = g_ceph_context->_conf.set_val("log_graylog_port", str);
ASSERT_EQ(-EINVAL, ret);
}
g_ceph_context->_conf.rm_val("log_graylog_port");
}
TEST(DaemonConfig, InvalidFloats) {
{
double bad_value = 2 * (double)std::numeric_limits<float>::max();
string str = boost::lexical_cast<string>(-bad_value);
int ret = g_ceph_context->_conf.set_val("log_stop_at_utilization", str);
ASSERT_EQ(-EINVAL, ret);
}
{
double bad_value = 2 * (double)std::numeric_limits<float>::max();
string str = boost::lexical_cast<string>(bad_value);
int ret = g_ceph_context->_conf.set_val("log_stop_at_utilization", str);
ASSERT_EQ(-EINVAL, ret);
}
{
int ret = g_ceph_context->_conf.set_val("log_stop_at_utilization", "not a float");
ASSERT_EQ(-EINVAL, ret);
}
}
/*
* Local Variables:
* compile-command: "cd ../../build ; \
* make unittest_daemon_config && ./bin/unittest_daemon_config"
* End:
*/
| 12,034 | 30.587927 | 110 |
cc
|
null |
ceph-main/src/test/detect-build-env-vars.sh
|
#!/usr/bin/env bash
if [ -n "$CEPH_BUILD_DIR" ] && [ -n "$CEPH_ROOT" ] && [ -n "$CEPH_BIN" ] && [ -n "$CEPH_LIB" ]; then
echo "Enivronment Variables Already Set"
elif [ -e CMakeCache.txt ]; then
echo "Environment Variables Not All Set, Detected Build System CMake"
echo "Setting Environment Variables"
export CEPH_ROOT=`grep ceph_SOURCE_DIR CMakeCache.txt | cut -d "=" -f 2`
export CEPH_BUILD_DIR=`pwd`
export CEPH_BIN=$CEPH_BUILD_DIR/bin
export CEPH_LIB=$CEPH_BUILD_DIR/lib
export PATH=$CEPH_BIN:$PATH
export LD_LIBRARY_PATH=$CEPH_LIB
else
echo "Please execute this command out of the proper directory"
exit 1
fi
| 639 | 31 | 100 |
sh
|
null |
ceph-main/src/test/docker-test-helper.sh
|
#!/usr/bin/env bash
#
# Copyright (C) 2014, 2015 Red Hat <[email protected]>
#
# Author: Loic Dachary <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Library Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library Public License for more details.
#
function get_image_name() {
local os_type=$1
local os_version=$2
echo ceph-$os_type-$os_version-$USER
}
function setup_container() {
local os_type=$1
local os_version=$2
local dockercmd=$3
local opts="$4"
# rm not valid here
opts=${opts//' --rm'};
local image=$(get_image_name $os_type $os_version)
local build=true
if $dockercmd images $image | grep --quiet "^$image " ; then
eval touch --date=$($dockercmd inspect $image | jq '.[0].Created') $image
found=$(find -L test/$os_type-$os_version/* -newer $image)
rm $image
if test -n "$found" ; then
$dockercmd rmi $image
else
build=false
fi
fi
if $build ; then
#
# In the dockerfile,
# replace environment variables %%FOO%% with their content
#
rm -fr dockerfile
cp --dereference --recursive test/$os_type-$os_version dockerfile
os_version=$os_version user_id=$(id -u) \
perl -p -e 's/%%(\w+)%%/$ENV{$1}/g' \
dockerfile/Dockerfile.in > dockerfile/Dockerfile
$dockercmd $opts build --tag=$image dockerfile
rm -fr dockerfile
fi
}
function get_upstream() {
git rev-parse --show-toplevel
}
function get_downstream() {
local os_type=$1
local os_version=$2
local image=$(get_image_name $os_type $os_version)
local upstream=$(get_upstream)
local dir=$(dirname $upstream)
echo "$dir/$image"
}
function setup_downstream() {
local os_type=$1
local os_version=$2
local ref=$3
local image=$(get_image_name $os_type $os_version)
local upstream=$(get_upstream)
local dir=$(dirname $upstream)
local downstream=$(get_downstream $os_type $os_version)
(
cd $dir
if ! test -d $downstream ; then
# Inspired by https://github.com/git/git/blob/master/contrib/workdir/git-new-workdir
mkdir -p $downstream/.git || return 1
for x in config refs logs/refs objects info hooks packed-refs remotes rr-cache
do
case $x in
*/*)
mkdir -p "$downstream/.git/$x"
;;
esac
ln -s "$upstream/.git/$x" "$downstream/.git/$x"
done
cp "$upstream/.git/HEAD" "$downstream/.git/HEAD"
fi
cd $downstream
git reset --hard $ref || return 1
git submodule sync --recursive || return 1
git submodule update --force --init --recursive || return 1
)
}
function run_in_docker() {
local os_type=$1
shift
local os_version=$1
shift
local ref=$1
shift
local dockercmd=$1
shift
local opts="$1"
shift
local script=$1
setup_downstream $os_type $os_version $ref || return 1
setup_container $os_type $os_version $dockercmd "$opts" || return 1
local downstream=$(get_downstream $os_type $os_version)
local image=$(get_image_name $os_type $os_version)
local upstream=$(get_upstream)
local ccache
mkdir -p $HOME/.ccache
ccache="--volume $HOME/.ccache:$HOME/.ccache"
user="--user $USER"
local cmd="$dockercmd run $opts --name $image --privileged $ccache"
cmd+=" --volume $downstream:$downstream"
cmd+=" --volume $upstream:$upstream"
if test "$dockercmd" = "podman" ; then
cmd+=" --userns=keep-id"
fi
local status=0
if test "$script" = "SHELL" ; then
echo Running: $cmd --tty --interactive --workdir $downstream $user $image bash
$cmd --tty --interactive --workdir $downstream $user $image bash
else
echo Running: $cmd --workdir $downstream $user $image "$@"
if ! $cmd --workdir $downstream $user $image "$@" ; then
status=1
fi
fi
return $status
}
function remove_all() {
local os_type=$1
local os_version=$2
local dockercmd=$3
local image=$(get_image_name $os_type $os_version)
$dockercmd rm $image
$dockercmd rmi $image
}
function usage() {
cat <<EOF
Run commands within Ceph sources, in a container. Use podman if available,
docker if not.
$0 [options] command args ...
[-h|--help] display usage
[--verbose] trace all shell lines
[--os-type type] docker image repository (centos, ubuntu, etc.)
(defaults to ubuntu)
[--os-version version] docker image tag (7 for centos, 16.04 for ubuntu, etc.)
(defaults to 16.04)
[--ref gitref] git reset --hard gitref before running the command
(defaults to git rev-parse HEAD)
[--all types+versions] list of docker image repositories and tags
[--shell] run an interactive shell in the container
[--remove-all] remove the container and the image for the specified types+versions
[--no-rm] don't remove the container when finished
[--opts options] run the container with 'options'
docker-test.sh must be run from a Ceph clone and it will run the
command in a container, using a copy of the clone so that long running
commands such as make check are not disturbed while development
continues. Here is a sample use case including an interactive session
and running a unit test:
$ grep PRETTY_NAME /etc/os-release
PRETTY_NAME="Ubuntu 16.04.7 LTS"
$ test/docker-test.sh --os-type centos --os-version 7 --shell
HEAD is now at 1caee81 autotools: add --enable-docker
bash-4.2$ pwd
/srv/ceph/ceph-centos-7
bash-4.2$ cat /etc/redhat-release
CentOS Linux release 7.6.1810 (Core)
bash-4.2$
$ time test/docker-test.sh --os-type centos --os-version 7 unittest_str_map
HEAD is now at 1caee81 autotools: add --enable-docker
Running main() from gtest_main.cc
[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from str_map
[ RUN ] str_map.json
[ OK ] str_map.json (1 ms)
[ RUN ] str_map.plaintext
[ OK ] str_map.plaintext (0 ms)
[----------] 2 tests from str_map (1 ms total)
[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran. (1 ms total)
[ PASSED ] 2 tests.
real 0m3.759s
user 0m0.074s
sys 0m0.051s
The --all argument is a bash associative array literal listing the
operating system version for each operating system type. For instance
docker-test.sh --all '([ubuntu]="16.04 17.04" [centos]="7")'
is strictly equivalent to
docker-test.sh --os-type ubuntu --os-version 16.04
docker-test.sh --os-type ubuntu --os-version 17.04
docker-test.sh --os-type centos --os-version 7
The --os-type and --os-version must be exactly as displayed by docker images:
$ docker images
REPOSITORY TAG IMAGE ID ...
centos 7 87e5b6b3ccc1 ...
ubuntu 16.04 6b4e8a7373fe ...
The --os-type value can be any string in the REPOSITORY column, the --os-version
can be any string in the TAG column.
The --shell and --remove actions are mutually exclusive.
Run make check in centos 7
docker-test.sh --os-type centos --os-version 7 -- make check
Run make check on a giant
docker-test.sh --ref giant -- make check
Run an interactive shell and set resolv.conf to use 172.17.42.1
docker-test.sh --opts --dns=172.17.42.1 --shell
Run make check on centos 7, ubuntu 16.04 and ubuntu 17.04
docker-test.sh --all '([ubuntu]="16.04 17.04" [centos]="7")' -- make check
EOF
}
function main_docker() {
local dockercmd="docker"
if type podman > /dev/null; then
dockercmd="podman"
fi
if ! $dockercmd ps > /dev/null 2>&1 ; then
echo "docker not available: $0"
return 0
fi
local temp
temp=$(getopt -o scht:v:o:a:r: --long remove-all,verbose,shell,no-rm,help,os-type:,os-version:,opts:,all:,ref: -n $0 -- "$@") || return 1
eval set -- "$temp"
local os_type=ubuntu
local os_version=16.04
local all
local remove=false
local shell=false
local opts
local ref=$(git rev-parse HEAD)
local no-rm=false
while true ; do
case "$1" in
--remove-all)
remove=true
shift
;;
--verbose)
set -xe
PS4='${BASH_SOURCE[0]}:$LINENO: ${FUNCNAME[0]}: '
shift
;;
-s|--shell)
shell=true
shift
;;
-h|--help)
usage
return 0
;;
-t|--os-type)
os_type=$2
shift 2
;;
-v|--os-version)
os_version=$2
shift 2
;;
-o|--opts)
opts="$2"
shift 2
;;
-a|--all)
all="$2"
shift 2
;;
-r|--ref)
ref="$2"
shift 2
;;
--no-rm)
no-rm=true
shift
;;
--)
shift
break
;;
*)
echo "unexpected argument $1"
return 1
;;
esac
done
if test -z "$all" ; then
all="([$os_type]=\"$os_version\")"
fi
declare -A os_type2versions
eval os_type2versions="$all"
if ! $no-rm ; then
opts+=" --rm"
fi
for os_type in ${!os_type2versions[@]} ; do
for os_version in ${os_type2versions[$os_type]} ; do
if $remove ; then
remove_all $os_type $os_version $dockercmd || return 1
elif $shell ; then
run_in_docker $os_type $os_version $ref $dockercmd "$opts" SHELL || return 1
else
run_in_docker $os_type $os_version $ref $dockercmd "$opts" "$@" || return 1
fi
done
done
}
| 10,592 | 28.839437 | 141 |
sh
|
null |
ceph-main/src/test/docker-test.sh
|
#!/usr/bin/env bash
#
# Copyright (C) 2014 Red Hat <[email protected]>
#
# Author: Loic Dachary <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Library Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library Public License for more details.
#
source test/docker-test-helper.sh
main_docker "$@"
| 649 | 31.5 | 70 |
sh
|
null |
ceph-main/src/test/encoding.cc
|
#include "include/buffer.h"
#include "include/encoding.h"
#include <fmt/format.h>
#include "gtest/gtest.h"
using namespace std;
template < typename T >
static void test_encode_and_decode(const T& src)
{
bufferlist bl(1000000);
encode(src, bl);
T dst;
auto i = bl.cbegin();
decode(dst, i);
ASSERT_EQ(src, dst) << "Encoding roundtrip changed the string: orig=" << src << ", but new=" << dst;
}
TEST(EncodingRoundTrip, StringSimple) {
string my_str("I am the very model of a modern major general");
test_encode_and_decode < std::string >(my_str);
}
TEST(EncodingRoundTrip, StringEmpty) {
string my_str("");
test_encode_and_decode < std::string >(my_str);
}
TEST(EncodingRoundTrip, StringNewline) {
string my_str("foo bar baz\n");
test_encode_and_decode < std::string >(my_str);
}
template <typename Size, typename T>
static void test_encode_and_nohead_nohead(Size len, const T& src)
{
bufferlist bl(1000000);
encode(len, bl);
encode_nohead(src, bl);
T dst;
auto i = bl.cbegin();
decode(len, i);
decode_nohead(len, dst, i);
ASSERT_EQ(src, dst) << "Encoding roundtrip changed the string: orig=" << src << ", but new=" << dst;
}
TEST(EncodingRoundTrip, StringNoHead) {
const string str("The quick brown fox jumps over the lazy dog");
auto size = str.size();
test_encode_and_nohead_nohead(static_cast<int>(size), str);
test_encode_and_nohead_nohead(static_cast<unsigned>(size), str);
test_encode_and_nohead_nohead(static_cast<uint32_t>(size), str);
test_encode_and_nohead_nohead(static_cast<__u32>(size), str);
test_encode_and_nohead_nohead(static_cast<size_t>(size), str);
}
TEST(EncodingRoundTrip, BufferListNoHead) {
bufferlist bl;
bl.append("is this a dagger which i see before me?");
auto size = bl.length();
test_encode_and_nohead_nohead(static_cast<int>(size), bl);
test_encode_and_nohead_nohead(static_cast<unsigned>(size), bl);
test_encode_and_nohead_nohead(static_cast<uint32_t>(size), bl);
test_encode_and_nohead_nohead(static_cast<__u32>(size), bl);
test_encode_and_nohead_nohead(static_cast<size_t>(size), bl);
}
typedef std::multimap < int, std::string > multimap_t;
typedef multimap_t::value_type my_val_ty;
namespace std {
static std::ostream& operator<<(std::ostream& oss, const multimap_t &multimap)
{
for (multimap_t::const_iterator m = multimap.begin();
m != multimap.end();
++m)
{
oss << m->first << "->" << m->second << " ";
}
return oss;
}
}
TEST(EncodingRoundTrip, Multimap) {
multimap_t multimap;
multimap.insert( my_val_ty(1, "foo") );
multimap.insert( my_val_ty(2, "bar") );
multimap.insert( my_val_ty(2, "baz") );
multimap.insert( my_val_ty(3, "lucky number 3") );
multimap.insert( my_val_ty(10000, "large number") );
test_encode_and_decode < multimap_t >(multimap);
}
///////////////////////////////////////////////////////
// ConstructorCounter
///////////////////////////////////////////////////////
template <typename T>
class ConstructorCounter
{
public:
ConstructorCounter() : data(0)
{
default_ctor++;
}
explicit ConstructorCounter(const T& data_)
: data(data_)
{
one_arg_ctor++;
}
ConstructorCounter(const ConstructorCounter &rhs)
: data(rhs.data)
{
copy_ctor++;
}
ConstructorCounter &operator=(const ConstructorCounter &rhs)
{
data = rhs.data;
assigns++;
return *this;
}
static void init(void)
{
default_ctor = 0;
one_arg_ctor = 0;
copy_ctor = 0;
assigns = 0;
}
static int get_default_ctor(void)
{
return default_ctor;
}
static int get_one_arg_ctor(void)
{
return one_arg_ctor;
}
static int get_copy_ctor(void)
{
return copy_ctor;
}
static int get_assigns(void)
{
return assigns;
}
bool operator<(const ConstructorCounter &rhs) const
{
return data < rhs.data;
}
bool operator==(const ConstructorCounter &rhs) const
{
return data == rhs.data;
}
friend void decode(ConstructorCounter &s, bufferlist::const_iterator& p)
{
decode(s.data, p);
}
friend void encode(const ConstructorCounter &s, bufferlist& p)
{
encode(s.data, p);
}
friend ostream& operator<<(ostream &oss, const ConstructorCounter &cc)
{
oss << cc.data;
return oss;
}
T data;
private:
static int default_ctor;
static int one_arg_ctor;
static int copy_ctor;
static int assigns;
};
template class ConstructorCounter <int32_t>;
template class ConstructorCounter <int16_t>;
typedef ConstructorCounter <int32_t> my_key_t;
typedef ConstructorCounter <int16_t> my_val_t;
typedef std::multimap < my_key_t, my_val_t > multimap2_t;
typedef multimap2_t::value_type val2_ty;
template <class T> int ConstructorCounter<T>::default_ctor = 0;
template <class T> int ConstructorCounter<T>::one_arg_ctor = 0;
template <class T> int ConstructorCounter<T>::copy_ctor = 0;
template <class T> int ConstructorCounter<T>::assigns = 0;
static std::ostream& operator<<(std::ostream& oss, const multimap2_t &multimap)
{
for (multimap2_t::const_iterator m = multimap.begin();
m != multimap.end();
++m)
{
oss << m->first << "->" << m->second << " ";
}
return oss;
}
TEST(EncodingRoundTrip, MultimapConstructorCounter) {
multimap2_t multimap2;
multimap2.insert( val2_ty(my_key_t(1), my_val_t(10)) );
multimap2.insert( val2_ty(my_key_t(2), my_val_t(20)) );
multimap2.insert( val2_ty(my_key_t(2), my_val_t(30)) );
multimap2.insert( val2_ty(my_key_t(3), my_val_t(40)) );
multimap2.insert( val2_ty(my_key_t(10000), my_val_t(1)) );
my_key_t::init();
my_val_t::init();
test_encode_and_decode < multimap2_t >(multimap2);
EXPECT_EQ(my_key_t::get_default_ctor(), 5);
EXPECT_EQ(my_key_t::get_one_arg_ctor(), 0);
EXPECT_EQ(my_key_t::get_copy_ctor(), 5);
EXPECT_EQ(my_key_t::get_assigns(), 0);
EXPECT_EQ(my_val_t::get_default_ctor(), 5);
EXPECT_EQ(my_val_t::get_one_arg_ctor(), 0);
EXPECT_EQ(my_val_t::get_copy_ctor(), 5);
EXPECT_EQ(my_val_t::get_assigns(), 0);
}
namespace ceph {
// make sure that the legacy encode/decode methods are selected
// over the ones defined using templates. the later is likely to
// be slower, see also the definition of "WRITE_INT_DENC" in
// include/denc.h
template<>
void encode<uint64_t, denc_traits<uint64_t>>(const uint64_t&,
bufferlist&,
uint64_t f) {
static_assert(denc_traits<uint64_t>::supported,
"should support new encoder");
static_assert(!denc_traits<uint64_t>::featured,
"should not be featured");
ASSERT_EQ(0UL, f);
// make sure the test fails if i get called
ASSERT_TRUE(false);
}
template<>
void encode<ceph_le64, denc_traits<ceph_le64>>(const ceph_le64&,
bufferlist&,
uint64_t f) {
static_assert(denc_traits<ceph_le64>::supported,
"should support new encoder");
static_assert(!denc_traits<ceph_le64>::featured,
"should not be featured");
ASSERT_EQ(0UL, f);
// make sure the test fails if i get called
ASSERT_TRUE(false);
}
}
namespace {
// search `underlying_type` in denc.h for supported underlying types
enum class Colour : int8_t { R,G,B };
ostream& operator<<(ostream& os, Colour c) {
switch (c) {
case Colour::R:
return os << "Colour::R";
case Colour::G:
return os << "Colour::G";
case Colour::B:
return os << "Colour::B";
default:
return os << "Colour::???";
}
}
}
TEST(EncodingRoundTrip, Integers) {
// int types
{
uint64_t i = 42;
test_encode_and_decode(i);
}
{
int16_t i = 42;
test_encode_and_decode(i);
}
{
bool b = true;
test_encode_and_decode(b);
}
{
bool b = false;
test_encode_and_decode(b);
}
// raw encoder
{
ceph_le64 i;
i = 42;
test_encode_and_decode(i);
}
// enum
{
test_encode_and_decode(Colour::R);
// this should not build, as the size of unsigned is not the same on
// different archs, that's why denc_traits<> intentionally leaves
// `int` and `unsigned int` out of supported types.
//
// enum E { R, G, B };
// test_encode_and_decode(R);
}
}
TEST(EncodingException, Macros) {
const struct {
buffer::malformed_input exc;
std::string expected_what;
} tests[] = {
{
DECODE_ERR_OLDVERSION(__PRETTY_FUNCTION__, 100, 200),
fmt::format("{} no longer understand old encoding version 100 < 200: Malformed input",
__PRETTY_FUNCTION__)
},
{
DECODE_ERR_PAST(__PRETTY_FUNCTION__),
fmt::format("{} decode past end of struct encoding: Malformed input",
__PRETTY_FUNCTION__)
}
};
for (auto& [exec, expected_what] : tests) {
try {
throw exec;
} catch (const exception& e) {
ASSERT_NE(string(e.what()).find(expected_what), string::npos);
}
}
}
TEST(small_encoding, varint) {
uint32_t v[][4] = {
/* value, varint bytes, signed varint bytes, signed varint bytes (neg) */
{0, 1, 1, 1},
{1, 1, 1, 1},
{2, 1, 1, 1},
{31, 1, 1, 1},
{32, 1, 1, 1},
{0xff, 2, 2, 2},
{0x100, 2, 2, 2},
{0xfff, 2, 2, 2},
{0x1000, 2, 2, 2},
{0x2000, 2, 3, 3},
{0x3fff, 2, 3, 3},
{0x4000, 3, 3, 3},
{0x4001, 3, 3, 3},
{0x10001, 3, 3, 3},
{0x20001, 3, 3, 3},
{0x40001, 3, 3, 3},
{0x80001, 3, 3, 3},
{0x7f0001, 4, 4, 4},
{0xff00001, 4, 5, 5},
{0x1ff00001, 5, 5, 5},
{0xffff0001, 5, 5, 5},
{0xffffffff, 5, 5, 5},
{1074790401, 5, 5, 5},
{0, 0, 0, 0}
};
for (unsigned i=0; v[i][1]; ++i) {
{
bufferlist bl;
{
auto app = bl.get_contiguous_appender(16, true);
denc_varint(v[i][0], app);
}
cout << std::hex << v[i][0] << "\t" << v[i][1] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][1]);
uint32_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_varint(u, p);
ASSERT_EQ(v[i][0], u);
}
{
bufferlist bl;
{
auto app = bl.get_contiguous_appender(16, true);
denc_signed_varint(v[i][0], app);
}
cout << std::hex << v[i][0] << "\t" << v[i][2] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][2]);
int32_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint(u, p);
ASSERT_EQ((int32_t)v[i][0], u);
}
{
bufferlist bl;
int64_t x = -(int64_t)v[i][0];
{
auto app = bl.get_contiguous_appender(16, true);
denc_signed_varint(x, app);
}
cout << std::dec << x << std::hex << "\t" << v[i][3] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][3]);
int64_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint(u, p);
ASSERT_EQ(x, u);
}
}
}
TEST(small_encoding, varint_lowz) {
uint32_t v[][4] = {
/* value, bytes encoded */
{0, 1, 1, 1},
{1, 1, 1, 1},
{2, 1, 1, 1},
{15, 1, 1, 1},
{16, 1, 1, 1},
{31, 1, 2, 2},
{63, 2, 2, 2},
{64, 1, 1, 1},
{0xff, 2, 2, 2},
{0x100, 1, 1, 1},
{0x7ff, 2, 2, 2},
{0xfff, 2, 3, 3},
{0x1000, 1, 1, 1},
{0x4000, 1, 1, 1},
{0x8000, 1, 1, 1},
{0x10000, 1, 2, 2},
{0x20000, 2, 2, 2},
{0x40000, 2, 2, 2},
{0x80000, 2, 2, 2},
{0x7f0000, 2, 2, 2},
{0xffff0000, 4, 4, 4},
{0xffffffff, 5, 5, 5},
{0x41000000, 3, 4, 4},
{0, 0, 0, 0}
};
for (unsigned i=0; v[i][1]; ++i) {
{
bufferlist bl;
{
auto app = bl.get_contiguous_appender(16, true);
denc_varint_lowz(v[i][0], app);
}
cout << std::hex << v[i][0] << "\t" << v[i][1] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][1]);
uint32_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_varint_lowz(u, p);
ASSERT_EQ(v[i][0], u);
}
{
bufferlist bl;
int64_t x = v[i][0];
{
auto app = bl.get_contiguous_appender(16, true);
denc_signed_varint_lowz(x, app);
}
cout << std::hex << x << "\t" << v[i][1] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][2]);
int64_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint_lowz(u, p);
ASSERT_EQ(x, u);
}
{
bufferlist bl;
int64_t x = -(int64_t)v[i][0];
{
auto app = bl.get_contiguous_appender(16, true);
denc_signed_varint_lowz(x, app);
}
cout << std::dec << x << "\t" << v[i][1] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][3]);
int64_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint_lowz(u, p);
ASSERT_EQ(x, u);
}
}
}
TEST(small_encoding, lba) {
uint64_t v[][2] = {
/* value, bytes encoded */
{0, 4},
{1, 4},
{0xff, 4},
{0x10000, 4},
{0x7f0000, 4},
{0xffff0000, 4},
{0x0fffffff, 4},
{0x1fffffff, 5},
{0xffffffff, 5},
{0x3fffffff000, 4},
{0x7fffffff000, 5},
{0x1fffffff0000, 4},
{0x3fffffff0000, 5},
{0xfffffff00000, 4},
{0x1fffffff00000, 5},
{0x41000000, 4},
{0, 0}
};
for (unsigned i=0; v[i][1]; ++i) {
bufferlist bl;
{
auto app = bl.get_contiguous_appender(16, true);
denc_lba(v[i][0], app);
}
cout << std::hex << v[i][0] << "\t" << v[i][1] << "\t";
bl.hexdump(cout, false);
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][1]);
uint64_t u;
auto p = bl.begin().get_current_ptr().cbegin();
denc_lba(u, p);
ASSERT_EQ(v[i][0], u);
}
}
| 13,939 | 24.625 | 102 |
cc
|
null |
ceph-main/src/test/escape.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/escape.h"
#include "gtest/gtest.h"
#include <stdint.h>
static std::string escape_xml_attrs(const char *str)
{
int len = escape_xml_attr_len(str);
char out[len];
escape_xml_attr(str, out);
return out;
}
static std::string escape_xml_stream(const char *str)
{
std::stringstream ss;
ss << xml_stream_escaper(str);
return ss.str();
}
TEST(EscapeXml, PassThrough) {
ASSERT_EQ(escape_xml_attrs("simplicity itself"), "simplicity itself");
ASSERT_EQ(escape_xml_stream("simplicity itself"), "simplicity itself");
ASSERT_EQ(escape_xml_attrs(""), "");
ASSERT_EQ(escape_xml_stream(""), "");
ASSERT_EQ(escape_xml_attrs("simple examples please!"), "simple examples please!");
ASSERT_EQ(escape_xml_stream("simple examples please!"), "simple examples please!");
}
TEST(EscapeXml, EntityRefs1) {
ASSERT_EQ(escape_xml_attrs("The \"scare quotes\""), "The "scare quotes"");
ASSERT_EQ(escape_xml_stream("The \"scare quotes\""), "The "scare quotes"");
ASSERT_EQ(escape_xml_attrs("I <3 XML"), "I <3 XML");
ASSERT_EQ(escape_xml_stream("I <3 XML"), "I <3 XML");
ASSERT_EQ(escape_xml_attrs("Some 'single' \"quotes\" here"),
"Some 'single' "quotes" here");
ASSERT_EQ(escape_xml_stream("Some 'single' \"quotes\" here"),
"Some 'single' "quotes" here");
}
TEST(EscapeXml, ControlChars) {
ASSERT_EQ(escape_xml_attrs("\x01\x02\x03"), "");
ASSERT_EQ(escape_xml_stream("\x01\x02\x03"), "");
ASSERT_EQ(escape_xml_attrs("abc\x7f"), "abc");
ASSERT_EQ(escape_xml_stream("abc\x7f"), "abc");
}
TEST(EscapeXml, Utf8) {
const char *cc1 = "\xe6\xb1\x89\xe5\xad\x97\n";
ASSERT_EQ(escape_xml_attrs(cc1), cc1);
ASSERT_EQ(escape_xml_stream(cc1), cc1);
ASSERT_EQ(escape_xml_attrs("<\xe6\xb1\x89\xe5\xad\x97>\n"), "<\xe6\xb1\x89\xe5\xad\x97>\n");
ASSERT_EQ(escape_xml_stream("<\xe6\xb1\x89\xe5\xad\x97>\n"), "<\xe6\xb1\x89\xe5\xad\x97>\n");
}
static std::string escape_json_attrs(const char *str, size_t src_len = 0)
{
if (!src_len)
src_len = strlen(str);
int len = escape_json_attr_len(str, src_len);
char out[len];
escape_json_attr(str, src_len, out);
return out;
}
static std::string escape_json_stream(const char *str, size_t src_len = 0)
{
if (!src_len)
src_len = strlen(str);
std::stringstream ss;
ss << json_stream_escaper(std::string_view(str, src_len));
return ss.str();
}
TEST(EscapeJson, PassThrough) {
ASSERT_EQ(escape_json_attrs("simplicity itself"), "simplicity itself");
ASSERT_EQ(escape_json_stream("simplicity itself"), "simplicity itself");
ASSERT_EQ(escape_json_attrs(""), "");
ASSERT_EQ(escape_json_stream(""), "");
ASSERT_EQ(escape_json_attrs("simple examples please!"), "simple examples please!");
ASSERT_EQ(escape_json_stream("simple examples please!"), "simple examples please!");
}
TEST(EscapeJson, Escapes1) {
ASSERT_EQ(escape_json_attrs("The \"scare quotes\""),
"The \\\"scare quotes\\\"");
ASSERT_EQ(escape_json_stream("The \"scare quotes\""),
"The \\\"scare quotes\\\"");
ASSERT_EQ(escape_json_attrs("I <3 JSON"), "I <3 JSON");
ASSERT_EQ(escape_json_stream("I <3 JSON"), "I <3 JSON");
ASSERT_EQ(escape_json_attrs("Some 'single' \"quotes\" here"),
"Some 'single' \\\"quotes\\\" here");
ASSERT_EQ(escape_json_stream("Some 'single' \"quotes\" here"),
"Some 'single' \\\"quotes\\\" here");
ASSERT_EQ(escape_json_attrs("tabs\tand\tnewlines\n, oh my"),
"tabs\\tand\\tnewlines\\n, oh my");
ASSERT_EQ(escape_json_stream("tabs\tand\tnewlines\n, oh my"),
"tabs\\tand\\tnewlines\\n, oh my");
}
TEST(EscapeJson, ControlChars) {
ASSERT_EQ(escape_json_attrs("\x01\x02\x03"), "\\u0001\\u0002\\u0003");
ASSERT_EQ(escape_json_stream("\x01\x02\x03"), "\\u0001\\u0002\\u0003");
ASSERT_EQ(escape_json_stream("\x00\x02\x03", 3), "\\u0000\\u0002\\u0003");
// json can't print binary data!
ASSERT_EQ(escape_json_stream("\x00\x7f\xff", 3), "\\u0000\\u007f\xff");
ASSERT_EQ(escape_json_attrs("abc\x7f"), "abc\\u007f");
ASSERT_EQ(escape_json_stream("abc\x7f"), "abc\\u007f");
}
TEST(EscapeJson, Utf8) {
EXPECT_EQ(escape_json_attrs("\xe6\xb1\x89\xe5\xad\x97\n"), "\xe6\xb1\x89\xe5\xad\x97\\n");
EXPECT_EQ(escape_json_stream("\xe6\xb1\x89\xe5\xad\x97\n"), "\xe6\xb1\x89\xe5\xad\x97\\n");
}
| 4,786 | 36.108527 | 101 |
cc
|
null |
ceph-main/src/test/fooclass.cc
|
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include "objclass/objclass.h"
CLS_VER(1,0)
CLS_NAME(foo)
cls_handle_t h_class;
cls_method_handle_t h_foo;
int foo_method(cls_method_context_t ctx, char *indata, int datalen,
char **outdata, int *outdatalen)
{
int i;
cls_log("hello world, this is foo");
cls_log("indata=%s", indata);
*outdata = (char *)malloc(128);
for (i=0; i<strlen(indata) + 1; i++) {
if (indata[i] == '1') {
(*outdata)[i] = 'I';
} else {
(*outdata)[i] = indata[i];
}
}
*outdatalen = strlen(*outdata) + 1;
cls_log("outdata=%s", *outdata);
return 0;
}
void class_init()
{
cls_log("Loaded foo class!");
cls_register("foo", &h_class);
cls_register_method(h_class, "foo", foo_method, &h_foo);
return;
}
| 817 | 15.693878 | 67 |
cc
|
null |
ceph-main/src/test/formatter.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "gtest/gtest.h"
#include "common/Formatter.h"
#include "common/HTMLFormatter.h"
#include <sstream>
#include <string>
using namespace ceph;
using std::ostringstream;
TEST(JsonFormatter, Simple1) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_int("a", 1);
fmt.dump_int("b", 2);
fmt.dump_int("c", 3);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "{\"a\":1,\"b\":2,\"c\":3}");
}
TEST(JsonFormatter, Simple2) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.open_object_section("foo");
fmt.open_object_section("bar");
fmt.dump_int("int", 0xf00000000000ll);
fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
fmt.dump_float("float", 1.234);
fmt.close_section();
fmt.dump_string("string", "str");
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "{\"bar\":{\"int\":263882790666240,\
\"unsigned\":9223372036854775809,\"float\":1.234},\
\"string\":\"str\"}");
}
TEST(JsonFormatter, CunningFloats) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_float("long", 1.0 / 7);
fmt.dump_float("big", 12345678901234567890.0);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "{\"long\":0.14285714285714285,\"big\":1.2345678901234567e+19}");
}
TEST(JsonFormatter, Empty) {
ostringstream oss;
JSONFormatter fmt(false);
fmt.flush(oss);
ASSERT_EQ(oss.str(), "");
}
TEST(XmlFormatter, Simple1) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_int("a", 1);
fmt.dump_int("b", 2);
fmt.dump_int("c", 3);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><a>1</a><b>2</b><c>3</c></foo>");
}
TEST(XmlFormatter, Simple2) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.open_object_section("bar");
fmt.dump_int("int", 0xf00000000000ll);
fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
fmt.dump_float("float", 1.234);
fmt.close_section();
fmt.dump_string("string", "str");
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><bar>\
<int>263882790666240</int>\
<unsigned>9223372036854775809</unsigned>\
<float>1.234</float>\
</bar><string>str</string>\
</foo>");
}
TEST(XmlFormatter, Empty) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.flush(oss);
ASSERT_EQ(oss.str(), "");
}
TEST(XmlFormatter, DumpStream1) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.dump_stream("blah") << "hithere";
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<blah>hithere</blah>");
}
TEST(XmlFormatter, DumpStream2) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah></foo>");
}
TEST(XmlFormatter, DumpStream3) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><blah>hithere</blah><pi>0.128</pi></foo>");
}
TEST(XmlFormatter, DTD) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.output_header();
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><blah>hithere</blah><pi>0.128</pi></foo>");
}
TEST(XmlFormatter, Clear) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.output_header();
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><blah>hithere</blah><pi>0.128</pi></foo>");
ostringstream oss2;
fmt.flush(oss2);
ASSERT_EQ(oss2.str(), "");
ostringstream oss3;
fmt.reset();
fmt.flush(oss3);
ASSERT_EQ(oss3.str(), "");
}
TEST(XmlFormatter, NamespaceTest) {
ostringstream oss;
XMLFormatter fmt(false);
fmt.output_header();
fmt.open_array_section_in_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
"<blah>hithere</blah><pi>0.128</pi></foo>");
}
TEST(XmlFormatter, DumpFormatNameSpaceTest) {
ostringstream oss1;
XMLFormatter fmt(false);
fmt.dump_format_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/",
"%s","bar");
fmt.flush(oss1);
ASSERT_EQ(oss1.str(),
"<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">bar</foo>");
// Testing with a null ns..should be same as dump format
ostringstream oss2;
fmt.reset();
fmt.dump_format_ns("foo",NULL,"%s","bar");
fmt.flush(oss2);
ASSERT_EQ(oss2.str(),"<foo>bar</foo>");
}
TEST(HtmlFormatter, Simple1) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.dump_int("a", 1);
fmt.dump_int("b", 2);
fmt.dump_int("c", 3);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><li>a: 1</li><li>b: 2</li><li>c: 3</li></foo>");
}
TEST(HtmlFormatter, Simple2) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_object_section("foo");
fmt.open_object_section("bar");
fmt.dump_int("int", 0xf00000000000ll);
fmt.dump_unsigned("unsigned", 0x8000000000000001llu);
fmt.dump_float("float", 1.234);
fmt.close_section();
fmt.dump_string("string", "str");
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><bar>\
<li>int: 263882790666240</li>\
<li>unsigned: 9223372036854775809</li>\
<li>float: 1.234</li>\
</bar><li>string: str</li>\
</foo>");
}
TEST(HtmlFormatter, Empty) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.flush(oss);
ASSERT_EQ(oss.str(), "");
}
TEST(HtmlFormatter, DumpStream1) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.dump_stream("blah") << "hithere";
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<li>blah: hithere</li>");
}
TEST(HtmlFormatter, DumpStream2) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li></foo>");
}
TEST(HtmlFormatter, DumpStream3) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<foo><li>blah: hithere</li><li>pi: 0.128</li></foo>");
}
TEST(HtmlFormatter, DTD) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><li>blah: hithere</li><li>pi: 0.128</li></foo>");
}
TEST(HtmlFormatter, Clear) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
fmt.open_array_section("foo");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo><li>blah: hithere</li><li>pi: 0.128</li></foo>");
ostringstream oss2;
fmt.flush(oss2);
ASSERT_EQ(oss2.str(), "");
ostringstream oss3;
fmt.reset();
fmt.flush(oss3);
ASSERT_EQ(oss3.str(), "");
}
TEST(HtmlFormatter, NamespaceTest) {
ostringstream oss;
HTMLFormatter fmt(false);
fmt.write_raw_data(HTMLFormatter::XML_1_DTD);
fmt.open_array_section_in_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/");
fmt.dump_stream("blah") << "hithere";
fmt.dump_float("pi", 0.128);
fmt.close_section();
fmt.flush(oss);
ASSERT_EQ(oss.str(), "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<foo xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
"<li>blah: hithere</li><li>pi: 0.128</li></foo>");
}
TEST(HtmlFormatter, DumpFormatNameSpaceTest) {
ostringstream oss1;
HTMLFormatter fmt(false);
fmt.dump_format_ns("foo",
"http://s3.amazonaws.com/doc/2006-03-01/",
"%s","bar");
fmt.flush(oss1);
ASSERT_EQ(oss1.str(),
"<li xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">foo: bar</li>");
// Testing with a null ns..should be same as dump format
ostringstream oss2;
fmt.reset();
fmt.dump_format_ns("foo",NULL,"%s","bar");
fmt.flush(oss2);
ASSERT_EQ(oss2.str(),"<li>foo: bar</li>");
}
| 9,231 | 25.005634 | 88 |
cc
|
null |
ceph-main/src/test/gather.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 Greg Farnum <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "include/Context.h"
#include "gtest/gtest.h"
class C_Checker : public Context {
public:
bool *finish_called;
int *result;
C_Checker(bool* _finish_called, int *r) :
finish_called(_finish_called), result(r) {}
void finish(int r) override { *finish_called = true; *result = r; }
};
TEST(ContextGather, Constructor) {
C_GatherBuilder gather(g_ceph_context);
EXPECT_FALSE(gather.has_subs());
EXPECT_TRUE(gather.get() == NULL);
}
TEST(ContextGather, OneSub) {
C_GatherBuilder gather(g_ceph_context);
Context *sub = gather.new_sub();
EXPECT_EQ(1, gather.num_subs_created());
EXPECT_EQ(1, gather.num_subs_remaining());
bool finish_called = false;
int result = 0;
C_Checker *checker = new C_Checker(&finish_called, &result);
gather.set_finisher(checker);
gather.activate();
sub->complete(0);
EXPECT_TRUE(finish_called);
EXPECT_EQ(0, result);
}
TEST(ContextGather, ManySubs) {
bool finish_called = false;
int result = 0;
C_GatherBuilder gather(g_ceph_context, new C_Checker(&finish_called, &result));
int sub_count = 8;
Context* subs[sub_count];
//create subs and test
for (int i = 0; i < sub_count; ++i) {
subs[i] = gather.new_sub();
EXPECT_EQ(i+1, gather.num_subs_created());
EXPECT_EQ(i+1, gather.num_subs_remaining());
}
EXPECT_TRUE(gather.has_subs());
gather.activate();
//finish all except one sub
for (int j = 0; j < sub_count - 1; ++j) {
subs[j]->complete(0);
EXPECT_FALSE(finish_called);
}
//finish last one and check asserts
subs[sub_count-1]->complete(0);
EXPECT_TRUE(finish_called);
}
TEST(ContextGather, AlternatingSubCreateFinish) {
C_GatherBuilder gather(g_ceph_context);
int sub_count = 8;
bool finish_called = false;
int result = 0;
C_Checker *checker = new C_Checker(&finish_called, &result);
gather.set_finisher(checker);
Context* subs[sub_count];
//create half the subs
for (int i = 0; i < sub_count / 2; ++i) {
subs[i] = gather.new_sub();
EXPECT_EQ(i + 1, gather.num_subs_created());
EXPECT_EQ(i + 1, gather.num_subs_remaining());
}
//alternate finishing first half of subs and creating last half of subs
for (int j = 0; j < sub_count / 2; ++j) {
subs[j]->complete(0);
subs[sub_count / 2 + j] = gather.new_sub();
}
gather.activate();
//finish last half of subs
for (int k = sub_count / 2; k < sub_count; ++k) {
subs[k]->complete(0);
}
EXPECT_TRUE(finish_called);
}
| 2,887 | 26.769231 | 81 |
cc
|
null |
ceph-main/src/test/heartbeat_map.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/HeartbeatMap.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
using namespace ceph;
TEST(HeartbeatMap, Healthy) {
HeartbeatMap hm(g_ceph_context);
heartbeat_handle_d *h = hm.add_worker("one", pthread_self());
hm.reset_timeout(h, ceph::make_timespan(9), ceph::make_timespan(18));
bool healthy = hm.is_healthy();
ASSERT_TRUE(healthy);
hm.remove_worker(h);
}
TEST(HeartbeatMap, Unhealth) {
HeartbeatMap hm(g_ceph_context);
heartbeat_handle_d *h = hm.add_worker("one", pthread_self());
hm.reset_timeout(h, ceph::make_timespan(1), ceph::make_timespan(3));
sleep(2);
bool healthy = hm.is_healthy();
ASSERT_FALSE(healthy);
hm.remove_worker(h);
}
| 1,172 | 25.066667 | 71 |
cc
|
null |
ceph-main/src/test/kv_store_bench.cc
|
/*
* KvStoreBench.cc
*
* Created on: Aug 23, 2012
* Author: eleanor
*/
#include "test/kv_store_bench.h"
#include "key_value_store/key_value_structure.h"
#include "key_value_store/kv_flat_btree_async.h"
#include "include/rados/librados.hpp"
#include "test/omap_bench.h"
#include "common/ceph_argparse.h"
#include <string>
#include <climits>
#include <iostream>
#include <sstream>
#include <cmath>
using std::stringstream;
using std::cout;
using std::string;
using std::pair;
using std::make_pair;
using std::map;
using std::cerr;
KvStoreBench::KvStoreBench()
: entries(30),
ops(100),
clients(5),
key_size(5),
val_size(7),
max_ops_in_flight(8),
clear_first(false),
k(2),
cache_size(10),
cache_refresh(1),
client_name("admin"),
verbose(false),
kvs(NULL),
ops_in_flight(0),
rados_id("admin"),
pool_name("rbd"),
io_ctx_ready(false)
{
probs[25] = 'i';
probs[50] = 'u';
probs[75] = 'd';
probs[100] = 'r';
}
KvStoreBench::~KvStoreBench()
{
if (io_ctx_ready) {
librados::ObjectWriteOperation owo;
owo.remove();
io_ctx.operate(client_name + ".done-setting", &owo);
}
delete kvs;
}
int KvStoreBench::setup(int argc, const char** argv) {
auto args = argv_to_vec(argc, argv);
srand(time(NULL));
stringstream help;
help
<< "Usage: KvStoreBench [options]\n"
<< "Generate latency and throughput statistics for the key value store\n"
<< "\n"
<< "There are two sets of options - workload options affect the kind of\n"
<< "test to run, while algorithm options affect how the key value\n"
<< "store handles the workload.\n"
<< "\n"
<< "There are about entries / k objects in the store to begin with.\n"
<< "Higher k values reduce the likelihood of splits and the likelihood\n"
<< "multiple writers simultaneously faling to write because an object \n"
<< "is full, but having a high k also means there will be more object\n"
<< "contention.\n"
<< "\n"
<< "WORKLOAD OPTIONS\n"
<< " --name <client name> client name (default admin)\n"
<< " --entries <number> number of key/value pairs to store initially\n"
<< " (default " << entries << ")\n"
<< " --ops <number> number of operations to run\n"
<< " --keysize <number> number of characters per key (default " << key_size << ")\n"
<< " --valsize <number> number of characters per value (default " << val_size << ")\n"
<< " -t <number> number of operations in flight concurrently\n"
<< " (default " << max_ops_in_flight << ")\n"
<< " --clients <number> tells this instance how many total clients are. Note that\n"
<< " changing this does not change the number of clients."
<< " -d <insert> <update> <delete> <read> percent (1-100) of operations that should be of each type\n"
<< " (default 25 25 25 25)\n"
<< " -r <number> random seed to use (default time(0))\n"
<< "ALGORITHM OPTIONS\n"
<< " --kval k, where each object has a number of entries\n"
<< " >= k and <= 2k.\n"
<< " --cache-size number of index entries to keep in cache\n"
<< " (default " << cache_size << ")\n"
<< " --cache-refresh percent (1-100) of cache-size to read each \n"
<< " time the index is read\n"
<< "OTHER OPTIONS\n"
<< " --verbosity-on display debug output\n"
<< " --clear-first delete all existing objects in the pool before running tests\n";
for (unsigned i = 0; i < args.size(); i++) {
if(i < args.size() - 1) {
if (strcmp(args[i], "--ops") == 0) {
ops = atoi(args[i+1]);
} else if (strcmp(args[i], "--entries") == 0) {
entries = atoi(args[i+1]);
} else if (strcmp(args[i], "--kval") == 0) {
k = atoi(args[i+1]);
} else if (strcmp(args[i], "--keysize") == 0) {
key_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--valsize") == 0) {
val_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--cache-size") == 0) {
cache_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--cache-refresh") == 0) {
auto temp = atoi(args[i+1]);
assert (temp != 0);
cache_refresh = 100 / (double)temp;
} else if (strcmp(args[i], "-t") == 0) {
max_ops_in_flight = atoi(args[i+1]);
} else if (strcmp(args[i], "--clients") == 0) {
clients = atoi(args[i+1]);
} else if (strcmp(args[i], "-d") == 0) {
if (i + 4 >= args.size()) {
cout << "Invalid arguments after -d: there must be 4 of them."
<< std::endl;
continue;
} else {
probs.clear();
int sum = atoi(args[i + 1]);
probs[sum] = 'i';
sum += atoi(args[i + 2]);
probs[sum] = 'u';
sum += atoi(args[i + 3]);
probs[sum] = 'd';
sum += atoi(args[i + 4]);
probs[sum] = 'r';
if (sum != 100) {
cout << "Invalid arguments after -d: they must add to 100."
<< std::endl;
}
}
} else if (strcmp(args[i], "--name") == 0) {
client_name = args[i+1];
} else if (strcmp(args[i], "-r") == 0) {
srand(atoi(args[i+1]));
}
} else if (strcmp(args[i], "--verbosity-on") == 0) {
verbose = true;
} else if (strcmp(args[i], "--clear-first") == 0) {
clear_first = true;
} else if (strcmp(args[i], "--help") == 0) {
cout << help.str() << std::endl;
exit(1);
}
}
KvFlatBtreeAsync * kvba = new KvFlatBtreeAsync(k, client_name, cache_size,
cache_refresh, verbose);
kvs = kvba;
int r = rados.init(rados_id.c_str());
if (r < 0) {
cout << "error during init" << std::endl;
return r;
}
r = rados.conf_parse_argv(argc, argv);
if (r < 0) {
cout << "error during parsing args" << std::endl;
return r;
}
r = rados.conf_parse_env(NULL);
if (r < 0) {
cout << "error during parsing env" << std::endl;
return r;
}
r = rados.conf_read_file(NULL);
if (r < 0) {
cout << "error during read file" << std::endl;
return r;
}
r = rados.connect();
if (r < 0) {
cout << "error during connect: " << r << std::endl;
return r;
}
r = rados.ioctx_create(pool_name.c_str(), io_ctx);
if (r < 0) {
cout << "error creating io ctx" << std::endl;
rados.shutdown();
return r;
}
io_ctx_ready = true;
if (clear_first) {
librados::NObjectIterator it;
for (it = io_ctx.nobjects_begin(); it != io_ctx.nobjects_end(); ++it) {
librados::ObjectWriteOperation rm;
rm.remove();
io_ctx.operate(it->get_oid(), &rm);
}
}
int err = kvs->setup(argc, argv);
if (err < 0 && err != -17) {
cout << "error during setup of kvs: " << err << std::endl;
return err;
}
return 0;
}
string KvStoreBench::random_string(int len) {
string ret;
string alphanum = "0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < len; ++i) {
ret.push_back(alphanum[rand() % (alphanum.size() - 1)]);
}
return ret;
}
pair<string, bufferlist> KvStoreBench::rand_distr(bool new_elem) {
pair<string, bufferlist> ret;
if (new_elem) {
ret = make_pair(random_string(key_size),
KvFlatBtreeAsync::to_bl(random_string(val_size)));
key_set.insert(ret.first);
} else {
if (key_set.size() == 0) {
return make_pair("",KvFlatBtreeAsync::to_bl(""));
}
string get_string = random_string(key_size);
std::set<string>::iterator it = key_set.lower_bound(get_string);
if (it == key_set.end()) {
ret.first = *(key_set.rbegin());
} else {
ret.first = *it;
}
ret.second = KvFlatBtreeAsync::to_bl(random_string(val_size));
}
return ret;
}
int KvStoreBench::test_random_insertions() {
int err;
if (entries == 0) {
return 0;
}
stringstream prev_ss;
prev_ss << (atoi(client_name.c_str()) - 1);
string prev_rid = prev_ss.str();
stringstream last_ss;
if (client_name.size() > 1) {
last_ss << client_name.substr(0,client_name.size() - 2);
}
last_ss << clients - 1;
string last_rid = client_name == "admin" ? "admin" : last_ss.str();
map<string, bufferlist> big_map;
for (int i = 0; i < entries; i++) {
bufferlist bfr;
bfr.append(random_string(7));
big_map[random_string(5)] = bfr;
}
uint64_t uint;
time_t t;
if (client_name[client_name.size() - 1] != '0' && client_name != "admin") {
do {
librados::ObjectReadOperation oro;
oro.stat(&uint, &t, &err);
err = io_ctx.operate(prev_rid + ".done-setting", &oro, NULL);
if (verbose) cout << "reading " << prev_rid << ": err = " << err
<< std::endl;
} while (err != 0);
cout << "detected " << prev_rid << ".done-setting" << std::endl;
}
cout << "testing random insertions";
err = kvs->set_many(big_map);
if (err < 0) {
cout << "error setting things" << std::endl;
return err;
}
librados::ObjectWriteOperation owo;
owo.create(true);
io_ctx.operate(client_name + ".done-setting", &owo);
cout << "created " << client_name + ".done-setting. waiting for "
<< last_rid << ".done-setting" << std::endl;
do {
librados::ObjectReadOperation oro;
oro.stat(&uint, &t, &err);
err = io_ctx.operate(last_rid + ".done-setting", &oro, NULL);
} while (err != 0);
cout << "detected " << last_rid << ".done-setting" << std::endl;
return err;
}
void KvStoreBench::aio_callback_timed(int * err, void *arg) {
timed_args *args = reinterpret_cast<timed_args *>(arg);
ceph::mutex * ops_in_flight_lock = &args->kvsb->ops_in_flight_lock;
ceph::mutex * data_lock = &args->kvsb->data_lock;
ceph::condition_variable * op_avail = &args->kvsb->op_avail;
int *ops_in_flight = &args->kvsb->ops_in_flight;
if (*err < 0 && *err != -61) {
cerr << "Error during " << args->op << " operation: " << *err << std::endl;
}
args->sw.stop_time();
double time = args->sw.get_time();
args->sw.clear();
data_lock->lock();
//latency
args->kvsb->data.latency_jf.open_object_section("latency");
args->kvsb->data.latency_jf.dump_float(string(1, args->op).c_str(),
time);
args->kvsb->data.latency_jf.close_section();
//throughput
args->kvsb->data.throughput_jf.open_object_section("throughput");
args->kvsb->data.throughput_jf.dump_unsigned(string(1, args->op).c_str(),
ceph_clock_now());
args->kvsb->data.throughput_jf.close_section();
data_lock->unlock();
ops_in_flight_lock->lock();
(*ops_in_flight)--;
op_avail->notify_all();
ops_in_flight_lock->unlock();
delete args;
}
int KvStoreBench::test_teuthology_aio(next_gen_t distr,
const map<int, char> &probs)
{
int err = 0;
cout << "inserting initial entries..." << std::endl;
err = test_random_insertions();
if (err < 0) {
return err;
}
cout << "finished inserting initial entries. Waiting 10 seconds for everyone"
<< " to catch up..." << std::endl;
sleep(10);
cout << "done waiting. Starting random operations..." << std::endl;
std::unique_lock l{ops_in_flight_lock};
for (int i = 0; i < ops; i++) {
ceph_assert(ops_in_flight <= max_ops_in_flight);
if (ops_in_flight == max_ops_in_flight) {
op_avail.wait(l);
ceph_assert(ops_in_flight < max_ops_in_flight);
}
cout << "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" << i + 1 << " / "
<< ops << std::endl;
timed_args * cb_args = new timed_args(this);
pair<string, bufferlist> kv;
int random = (rand() % 100);
cb_args->op = probs.lower_bound(random)->second;
switch (cb_args->op) {
case 'i':
kv = (((KvStoreBench *)this)->*distr)(true);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_set(kv.first, kv.second, false, aio_callback_timed,
cb_args, &cb_args->err);
break;
case 'u':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_set(kv.first, kv.second, true, aio_callback_timed,
cb_args, &cb_args->err);
break;
case 'd':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
key_set.erase(kv.first);
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_remove(kv.first, aio_callback_timed, cb_args, &cb_args->err);
break;
case 'r':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
delete cb_args;
continue;
}
ops_in_flight++;
cb_args->sw.start_time();
kvs->aio_get(kv.first, &cb_args->val, aio_callback_timed,
cb_args, &cb_args->err);
break;
default:
// shouldn't happen here
assert(false);
}
}
op_avail.wait(l, [this] { return ops_in_flight <= 0; });
print_time_data();
return err;
}
int KvStoreBench::test_teuthology_sync(next_gen_t distr,
const map<int, char> &probs)
{
int err = 0;
err = test_random_insertions();
if (err < 0) {
return err;
}
sleep(10);
for (int i = 0; i < ops; i++) {
StopWatch sw;
pair<char, double> d;
cout << "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t" << i + 1 << " / "
<< ops << std::endl;
pair<string, bufferlist> kv;
int random = (rand() % 100);
d.first = probs.lower_bound(random)->second;
switch (d.first) {
case 'i':
kv = (((KvStoreBench *)this)->*distr)(true);
if (kv.first == "") {
i--;
continue;
}
sw.start_time();
err = kvs->set(kv.first, kv.second, true);
sw.stop_time();
if (err < 0) {
cout << "Error setting " << kv << ": " << err << std::endl;
return err;
}
break;
case 'u':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
continue;
}
sw.start_time();
err = kvs->set(kv.first, kv.second, true);
sw.stop_time();
if (err < 0 && err != -61) {
cout << "Error updating " << kv << ": " << err << std::endl;
return err;
}
break;
case 'd':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
continue;
}
key_set.erase(kv.first);
sw.start_time();
err = kvs->remove(kv.first);
sw.stop_time();
if (err < 0 && err != -61) {
cout << "Error removing " << kv << ": " << err << std::endl;
return err;
}
break;
case 'r':
kv = (((KvStoreBench *)this)->*distr)(false);
if (kv.first == "") {
i--;
continue;
}
bufferlist val;
sw.start_time();
err = kvs->get(kv.first, &kv.second);
sw.stop_time();
if (err < 0 && err != -61) {
cout << "Error getting " << kv << ": " << err << std::endl;
return err;
}
break;
}
double time = sw.get_time();
d.second = time;
sw.clear();
//latency
data.latency_jf.open_object_section("latency");
data.latency_jf.dump_float(string(1, d.first).c_str(),
time);
data.latency_jf.close_section();
}
print_time_data();
return err;
}
void KvStoreBench::print_time_data() {
cout << "========================================================\n";
cout << "latency:" << std::endl;
data.latency_jf.flush(cout);
cout << std::endl;
cout << "throughput:" << std::endl;
data.throughput_jf.flush(cout);
cout << "\n========================================================"
<< std::endl;
}
int KvStoreBench::teuthology_tests() {
int err = 0;
if (max_ops_in_flight > 1) {
err = test_teuthology_aio(&KvStoreBench::rand_distr, probs);
} else {
err = test_teuthology_sync(&KvStoreBench::rand_distr, probs);
}
return err;
}
int main(int argc, const char** argv) {
KvStoreBench kvsb;
int err = kvsb.setup(argc, argv);
if (err == 0) cout << "setup successful" << std::endl;
else{
cout << "error " << err << std::endl;
return err;
}
err = kvsb.teuthology_tests();
if (err < 0) return err;
return 0;
};
| 16,597 | 28.376991 | 123 |
cc
|
null |
ceph-main/src/test/kv_store_bench.h
|
/*
* Benchmarking suite for key-value store
*
* September 2, 2012
* Eleanor Cawthon
* [email protected]
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#ifndef KVSTOREBENCH_H_
#define KVSTOREBENCH_H_
#include "key_value_store/key_value_structure.h"
#include "key_value_store/kv_flat_btree_async.h"
#include "common/Clock.h"
#include "global/global_context.h"
#include "common/Cond.h"
#include <string>
#include <climits>
#include <cfloat>
#include <iostream>
/**
* stores pairings from op type to time taken for that op (for latency), and to
* time that op completed to the nearest second (for throughput).
*/
struct kv_bench_data {
JSONFormatter throughput_jf;
JSONFormatter latency_jf;
};
class KvStoreBench;
/**
* keeps track of the number of milliseconds between two events - used to
* measure latency
*/
struct StopWatch {
utime_t begin_time;
utime_t end_time;
void start_time() {
begin_time = ceph_clock_now();
}
void stop_time() {
end_time = ceph_clock_now();
}
double get_time() {
return (end_time - begin_time) * 1000;
}
void clear() {
begin_time = end_time = utime_t();
}
};
/**
* arguments passed to the callback method when the op is being timed
*/
struct timed_args {
StopWatch sw;
//kv_bench_data data;
KvStoreBench * kvsb;
ceph::buffer::list val;
int err;
char op;
timed_args ()
: kvsb(NULL),
err(0),
op(' ')
{};
timed_args (KvStoreBench * k)
: kvsb(k),
err(0),
op(' ')
{}
};
typedef std::pair<std::string, ceph::buffer::list> (KvStoreBench::*next_gen_t)(bool new_elem);
class KvStoreBench {
protected:
//test setup variables set from command line
int entries; //the number of entries to write initially
int ops; //the number of operations to time
int clients; //the total number of clients running this test - used
//in the aio test to coordinate the end of the initial sets
int key_size;//number of characters in keys to write
int val_size;//number of characters in values to write
int max_ops_in_flight;
bool clear_first;//if true, remove all objects in pool before starting tests
//variables passed to KeyValueStructure
int k;
int cache_size; //number of index entries to store in cache
double cache_refresh; //cache_size / cache_refresh entries are read each time
//the index is read
std::string client_name;
bool verbose;//if true, display debug output
//internal
std::map<int, char> probs;//map of numbers from 1 to 100 to chars representing
//operation types - used to generate random operations
std::set<std::string> key_set;//set of keys already in the data set
KeyValueStructure * kvs;
kv_bench_data data;//stores throughput and latency from completed tests
ceph::mutex data_lock = ceph::make_mutex("data lock");
ceph::condition_variable op_avail; // signaled when an op completes
int ops_in_flight;//number of operations currently in progress
ceph::mutex ops_in_flight_lock =
ceph::make_mutex("KvStoreBench::ops_in_flight_lock");
//these are used for cleanup and setup purposes - they are NOT passed to kvs!
librados::Rados rados;
std::string rados_id;
std::string pool_name;
bool io_ctx_ready;
librados::IoCtx io_ctx;
/**
* Prints JSON-formatted throughput and latency data.
*
* Throughput data is {'char representing the operation type':time the op
* completed to the nearest second}
* Latency is {'char representing the operation type':time taken by the op}
*/
void print_time_data();
public:
KvStoreBench();
//after this is called, objects created by the KeyValueStructure remain.
~KvStoreBench();
/**
* parses command line arguments, sets up this rados instance, clears the
* pool if clear_first is true and calls kvs->setup.
*/
int setup(int argc, const char** argv);
/**
* Returns a string of random characters of length len
*/
std::string random_string(int len);
/**
* Inserts entries random keys and values asynchronously.
*/
int test_random_insertions();
/**
* calls test_random_insertions, then does ops randomly chosen operations
* asynchronously, with max_ops_in_flight operations at a time.
*/
int test_teuthology_aio(next_gen_t distr, const std::map<int, char> &probs);
/**
* calls test_random_insertions, then does ops randomly chosen operations
* synchronously.
*/
int test_teuthology_sync(next_gen_t distr, const std::map<int, char> &probs);
/**
* returns a key-value pair. If new_elem is true, the key is randomly
* generated. If it is false, the key is selected from the keys currently in
* the key set.
*/
std::pair<std::string, ceph::buffer::list> rand_distr(bool new_elem);
/**
* Called when aio operations complete. Updates data.
*/
static void aio_callback_timed(int * err, void *arg);
/**
* Calls test_ methods. Change to call, for example, multiple runs of a test
* with different settings. Currently just calls test_teuthology_aio.
*/
int teuthology_tests();
};
#endif /* KVSTOREBENCH_H_ */
| 5,252 | 26.217617 | 94 |
h
|
null |
ceph-main/src/test/libcephfs_config.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "gtest/gtest.h"
#include "include/compat.h"
#include "include/cephfs/libcephfs.h"
#include <sstream>
#include <string>
#include <string.h>
using std::string;
TEST(LibCephConfig, SimpleSet) {
struct ceph_mount_info *cmount;
int ret = ceph_create(&cmount, NULL);
ASSERT_EQ(ret, 0);
ret = ceph_conf_set(cmount, "log_max_new", "21");
ASSERT_EQ(ret, 0);
char buf[128];
memset(buf, 0, sizeof(buf));
ret = ceph_conf_get(cmount, "log_max_new", buf, sizeof(buf));
ASSERT_EQ(ret, 0);
ASSERT_EQ(string("21"), string(buf));
ceph_shutdown(cmount);
}
TEST(LibCephConfig, ArgV) {
struct ceph_mount_info *cmount;
int ret = ceph_create(&cmount, NULL);
ASSERT_EQ(ret, 0);
const char *argv[] = { "foo", "--log_max_new", "2",
"--key", "my-key", NULL };
size_t argc = (sizeof(argv) / sizeof(argv[0])) - 1;
ceph_conf_parse_argv(cmount, argc, argv);
char buf[128];
memset(buf, 0, sizeof(buf));
ret = ceph_conf_get(cmount, "key", buf, sizeof(buf));
ASSERT_EQ(ret, 0);
ASSERT_EQ(string("my-key"), string(buf));
memset(buf, 0, sizeof(buf));
ret = ceph_conf_get(cmount, "log_max_new", buf, sizeof(buf));
ASSERT_EQ(ret, 0);
ASSERT_EQ(string("2"), string(buf));
ceph_shutdown(cmount);
}
| 1,645 | 24.323077 | 70 |
cc
|
null |
ceph-main/src/test/librgw_file.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "global/global_init.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t h_rgw = nullptr;
string uid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
typedef std::tuple<string, uint64_t, struct rgw_file_handle*> fid_type; //in c++2014 can alias...
typedef std::tuple<fid_type, std::vector<fid_type>> bucket_type;
std::vector<fid_type> fids1;
std::vector<bucket_type> bucket_matrix;
bool do_getattr = false;
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&h_rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(h_rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(h_rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
"/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, GETATTR_ROOT) {
if (do_getattr) {
if (! fs)
return;
struct stat st;
int ret = rgw_getattr(fs, fs->root_fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
extern "C" {
static int r1_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
// don't need arg--it would point to fids1
fids1.push_back(fid_type(name, offset, nullptr /* handle */));
return true; /* XXX ? */
}
}
TEST(LibRGW, LIST_BUCKETS) {
/* list buckets via readdir in fs root */
using std::get;
if (! fs)
return;
bool eof = false;
uint64_t offset = 0;
int ret = rgw_readdir(fs, fs->root_fh, &offset, r1_cb, &fids1, &eof,
RGW_READDIR_FLAG_NONE);
for (auto& fid : fids1) {
std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
<< std::endl;
/* push row for bucket into bucket_matrix */
bucket_matrix.push_back(bucket_type(fid, std::vector<fid_type>()));
}
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, LOOKUP_BUCKETS) {
using std::get;
if (! fs)
return;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row);
// auto& obj_vector = get<1>(fid_row);
struct rgw_file_handle *rgw_fh = nullptr;
ASSERT_EQ(0, rgw_lookup(fs, fs->root_fh, get<0>(fid).c_str(), &rgw_fh,
nullptr /* stat */, 0 /* mask */, 0 /* flags */));
get<2>(fid) = rgw_fh;
ASSERT_NE(get<2>(fid), nullptr);
}
}
TEST(LibRGW, GETATTR_BUCKETS) {
if (do_getattr) {
using std::get;
if (! fs)
return;
struct stat st;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row);
struct rgw_file_handle *rgw_fh = get<2>(fid);
ASSERT_EQ(0, rgw_getattr(fs, rgw_fh, &st, RGW_GETATTR_FLAG_NONE));
}
}
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
std::vector<fid_type>& obj_vector = *(static_cast<std::vector<fid_type>*>(arg));
obj_vector.push_back(fid_type(name, offset, nullptr));
return true; /* XXX ? */
}
}
TEST(LibRGW, LIST_OBJECTS) {
/* list objects via readdir, bucketwise */
using std::get;
if (! fs)
return;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row); // bucket
std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
struct rgw_file_handle *bucket_fh = get<2>(fid);
ldout(g_ceph_context, 0) << __func__ << " readdir on bucket " << get<0>(fid)
<< dendl;
bool eof = false;
uint64_t offset = 0;
int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &obj_vector, &eof,
RGW_READDIR_FLAG_NONE);
for (auto& obj : obj_vector) {
std::cout << "fname: " << get<0>(obj) << " fid: " << get<1>(obj)
<< std::endl;
}
ASSERT_EQ(ret, 0);
}
}
namespace rgw {
extern bool global_stop;
}
TEST(LibRGW, GETATTR_OBJECTS) {
if (do_getattr) {
using std::get;
struct stat st;
int ret;
rgw::global_stop = true;
for (auto& fid_row : bucket_matrix) {
auto& fid = get<0>(fid_row); // bucket
std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
struct rgw_file_handle *bucket_fh = get<2>(fid);
for (auto& obj : obj_vector) {
struct rgw_file_handle *obj_fh = nullptr;
std::string object_name = get<0>(obj);
ret = rgw_lookup(fs, bucket_fh, get<0>(obj).c_str(), &obj_fh,
nullptr /* stat */, 0 /* mask */, 0 /* flags */);
ASSERT_EQ(ret, 0);
get<2>(obj) = obj_fh; // stash obj_fh for cleanup
ASSERT_NE(get<2>(obj), nullptr);
ret = rgw_getattr(fs, obj_fh, &st,
RGW_GETATTR_FLAG_NONE); // now, getattr
ASSERT_EQ(ret, 0);
}
}
}
}
TEST(LibRGW, CLEANUP) {
int ret = 0;
using std::get;
/* release file handles */
for (auto& fid_row : bucket_matrix) {
auto& bucket = get<0>(fid_row); // bucket
std::vector<fid_type>& obj_vector = get<1>(fid_row); // objects in bucket
for (auto& obj : obj_vector) {
struct rgw_file_handle *obj_fh = get<2>(obj);
if (obj_fh) {
ret = rgw_fh_rele(fs, obj_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
}
// now the bucket
struct rgw_file_handle *bucket_fh = get<2>(bucket);
if (bucket_fh) {
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
}
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(h_rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
uid = val;
} else if (ceph_argparse_flag(args, arg_iter, "--getattr",
(char*) nullptr)) {
do_getattr = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 7,245 | 23.815068 | 99 |
cc
|
null |
ceph-main/src/test/librgw_file_aw.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include "xxhash.h"
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t rgw = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
bool do_create = false;
bool do_delete = false;
bool do_large = false;
bool do_verify = false;
bool do_hexdump = false;
string bucket_name = "sorrydave";
string object_name = "jocaml";
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *object_fh = nullptr;
typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
std::vector<fid_type> fids;
std::uniform_int_distribution<uint8_t> uint_dist;
std::mt19937 rng;
constexpr int iovcnt = 4;
constexpr int page_size = /* 65536 */ 4 * 1024*1024;
constexpr int seed = 8675309;
struct ZPage
{
char data[page_size];
uint64_t cksum;
}; /* ZPage */
struct ZPageSet
{
std::vector<ZPage*> pages;
struct iovec* iovs;
explicit ZPageSet(int n) {
pages.reserve(n);
iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = new ZPage();
for (int data_ix = 0; data_ix < page_size; ++data_ix) {
p->data[data_ix] = uint_dist(rng);
} // data_ix
p->cksum = XXH64(p->data, page_size, seed);
pages.emplace_back(p);
// and iovs
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
} // page_ix
}
int size() { return pages.size(); }
struct iovec* get_iovs() { return iovs; }
bool operator==(const ZPageSet& rhs) {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p1 = pages[page_ix];
ZPage* p2 = rhs.pages[page_ix];
if (p1->cksum != p2->cksum)
return false;
}
return true;
}
bool operator==(const rgw_uio* uio) {
uint64_t cksum;
int vix = 0, off = 0;
rgw_vio* vio = &uio->uio_vio[vix];
int vio_len = vio->vio_len;
char *data;
for (int ix = 0; ix < iovcnt; ++ix) {
ZPage* p1 = pages[ix];
data = static_cast<char*>(vio->vio_base) + off;
cksum = XXH64(data, page_size, seed);
if (p1->cksum != cksum) {
int r = memcmp(data, p1->data, page_size);
std::cout << "problem at ix " << ix << " r " << r<< std::endl;
return false;
}
off += page_size;
if (off >= vio_len) {
vio = &uio->uio_vio[++vix];
vio_len = vio->vio_len;
off = 0;
}
}
return true;
}
void cksum() {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
p->cksum = XXH64(p->data, page_size, seed);
}
}
void reset_iovs() { // VOP_READ and VOP_WRITE update
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
}
}
~ZPageSet() {
for (unsigned int ix = 0; ix < pages.size(); ++ix)
delete pages[ix];
free(iovs);
}
}; /* ZPageSet */
ZPageSet zp_set1{iovcnt}; // random data
ZPageSet zp_set2{iovcnt}; // random data in 64K pages
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, CREATE_BUCKET) {
if (do_create) {
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, LOOKUP_BUCKET) {
int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, LOOKUP_OBJECT) {
int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
}
#if 0
TEST(LibRGW, OPEN1) {
int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, PUT_OBJECT) {
size_t nbytes;
struct iovec *iovs = zp_set1.get_iovs();
off_t offset = 0;
for (int ix : {0, 1}) {
struct iovec *iov = &iovs[ix];
// quick check
sprintf(static_cast<char*>(iov->iov_base), "::hi mom (%d)", ix);
iov->iov_len = 14;
int ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
iov->iov_base, RGW_WRITE_FLAG_NONE);
offset += iov->iov_len;
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, iov->iov_len);
}
}
TEST(LibRGW, CLOSE1) {
int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, OPEN2) {
int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, GET_OBJECT) {
size_t nread;
off_t offset = 0;
struct iovec *iovs = zp_set1.get_iovs();
for (int ix : {2 , 3}) {
struct iovec *iov = &iovs[ix];
int ret = rgw_read(fs, object_fh, offset, iovs[ix-2].iov_len, &nread,
iov->iov_base, RGW_READ_FLAG_NONE);
iov->iov_len = nread;
offset += iov->iov_len;
ASSERT_EQ(ret, 0);
ASSERT_EQ(nread, iovs[ix-2].iov_len);
std::cout << "read: " << static_cast<char*>(iov->iov_base) << std::endl;
}
}
TEST(LibRGW, CLOSE2) {
int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
#endif
TEST (LibRGW, LARGE1) {
if (do_large) {
int ret;
ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
size_t nbytes;
struct iovec *iovs = zp_set1.get_iovs();
off_t offset = 0;
for (int ix = 0; ix < iovcnt; ++ix) {
struct iovec *iov = &iovs[ix];
// write iov->iov_len
ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
iov->iov_base, RGW_WRITE_FLAG_NONE);
offset += iov->iov_len;
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, iov->iov_len);
}
ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
} /* do_large */
}
TEST (LibRGW, LARGE2) {
if (do_large) {
int ret;
if (do_verify) {
ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
size_t nread;
off_t offset2 = 0;
struct iovec *iovs2 = zp_set2.get_iovs();
for (int ix = 0; ix < iovcnt; ++ix) {
struct iovec *iov2 = &iovs2[ix];
ret = rgw_read(fs, object_fh, offset2, iov2->iov_len, &nread,
iov2->iov_base, RGW_READ_FLAG_NONE);
iov2->iov_len = nread;
offset2 += iov2->iov_len;
ASSERT_EQ(ret, 0);
}
zp_set1.cksum();
zp_set2.cksum();
ASSERT_TRUE(zp_set1 == zp_set2);
ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
} /* do_large */
}
TEST(LibRGW, STAT_OBJECT) {
struct stat st;
int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
dout(15) << "rgw_getattr on " << object_name << " size = "
<< st.st_size << dendl;
}
TEST(LibRGW, DELETE_OBJECT) {
if (do_delete) {
int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, DELETE_BUCKET) {
if (do_delete) {
int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CLEANUP) {
int ret;
if (object_fh) {
ret = rgw_fh_rele(fs, object_fh, RGW_FH_RELE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--verify",
(char*) nullptr)) {
do_verify = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--large",
(char*) nullptr)) {
do_large = true;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 10,902 | 23.949657 | 79 |
cc
|
null |
ceph-main/src/test/librgw_file_cd.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t rgw = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
bool do_create = false;
bool do_delete = false;
bool do_multi = false;
int multi_cnt = 10;
string bucket_name = "sorrydave";
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, CREATE_BUCKET) {
if (do_create) {
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, DELETE_BUCKET) {
if (do_delete) {
int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CREATE_BUCKET_MULTI) {
if (do_multi) {
int ret;
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
for (int ix = 0; ix < multi_cnt; ++ix) {
string bn = bucket_name;
bn += to_string(ix);
ret = rgw_mkdir(fs, fs->root_fh, bn.c_str(), &st, create_mask, &fh,
RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
std::cout << "created: " << bn << std::endl;
}
}
}
TEST(LibRGW, DELETE_BUCKET_MULTI) {
if (do_multi) {
for (int ix = 0; ix < multi_cnt; ++ix) {
string bn = bucket_name;
bn += to_string(ix);
int ret = rgw_unlink(fs, fs->root_fh, bn.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
}
TEST(LibRGW, CLEANUP) {
// do nothing
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--multi",
(char*) nullptr)) {
do_multi = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 4,764 | 22.706468 | 79 |
cc
|
null |
ceph-main/src/test/librgw_file_gp.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include "xxhash.h"
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
librgw_t rgw = nullptr;
string uid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
bool do_pre_list = false;
bool do_put = false;
bool do_bulk = false;
bool do_writev = false;
bool do_readv = false;
bool do_verify = false;
bool do_get = false;
bool do_create = false;
bool do_delete = false;
bool do_stat = false; // stat objects (not buckets)
bool do_hexdump = false;
bool object_open = false;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name = "blastoff";
string object_name = "jocaml";
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *object_fh = nullptr;
typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
std::vector<fid_type> fids;
std::uniform_int_distribution<uint8_t> uint_dist;
std::mt19937 rng;
constexpr int iovcnt = 16;
constexpr int page_size = 65536;
constexpr int seed = 8675309;
struct ZPage
{
char data[page_size];
uint64_t cksum;
}; /* ZPage */
struct ZPageSet
{
std::vector<ZPage*> pages;
struct iovec* iovs;
explicit ZPageSet(int n) {
pages.reserve(n);
iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = new ZPage();
for (int data_ix = 0; data_ix < page_size; ++data_ix) {
p->data[data_ix] = uint_dist(rng);
} // data_ix
p->cksum = XXH64(p->data, page_size, seed);
pages.emplace_back(p);
// and iovs
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
} // page_ix
}
int size() { return pages.size(); }
struct iovec* get_iovs() { return iovs; }
bool operator==(const ZPageSet& rhs) {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p1 = pages[page_ix];
ZPage* p2 = rhs.pages[page_ix];
if (p1->cksum != p2->cksum)
return false;
}
return true;
}
bool operator==(const rgw_uio* uio) {
uint64_t cksum;
int vix = 0, off = 0;
rgw_vio* vio = &uio->uio_vio[vix];
int vio_len = vio->vio_len;
char *data;
for (int ix = 0; ix < iovcnt; ++ix) {
ZPage* p1 = pages[ix];
data = static_cast<char*>(vio->vio_base) + off;
cksum = XXH64(data, page_size, seed);
if (p1->cksum != cksum) {
int r = memcmp(data, p1->data, page_size);
std::cout << "problem at ix " << ix << " r " << r<< std::endl;
return false;
}
off += page_size;
if (off >= vio_len) {
vio = &uio->uio_vio[++vix];
vio_len = vio->vio_len;
off = 0;
}
}
return true;
}
void cksum() {
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
p->cksum = XXH64(p->data, page_size, seed);
}
}
void reset_iovs() { // VOP_READ and VOP_WRITE update
int n = size();
for (int page_ix = 0; page_ix < n; ++page_ix) {
ZPage* p = pages[page_ix];
struct iovec* iov = &iovs[page_ix];
iov->iov_base = p->data;
iov->iov_len = page_size;
}
}
~ZPageSet() {
for (unsigned int ix = 0; ix < pages.size(); ++ix)
delete pages[ix];
free(iovs);
}
}; /* ZPageSet */
rgw_uio uio[1];
ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
"/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, CREATE_BUCKET) {
if (do_create) {
struct stat st;
struct rgw_file_handle *fh;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, LOOKUP_BUCKET) {
int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat *st, uint32_t st_mask,
uint32_t flags) {
// don't need arg--it would point to fids
fids.push_back(fid_type(name, offset, nullptr));
return true; /* XXX ? */
}
}
TEST(LibRGW, LIST_OBJECTS) {
if (do_pre_list) {
/* list objects via readdir, bucketwise */
using std::get;
ldout(g_ceph_context, 0) << __func__ << " readdir on bucket "
<< bucket_name << dendl;
bool eof = false;
uint64_t offset = 0;
int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &fids,
&eof, RGW_READDIR_FLAG_NONE);
for (auto& fid : fids) {
std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
<< std::endl;
}
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, LOOKUP_OBJECT) {
if (do_get || do_stat || do_put || do_bulk || do_readv || do_writev) {
int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, OBJ_OPEN) {
if (do_get || do_put || do_readv || do_writev) {
int ret = rgw_open(fs, object_fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(ret, 0);
object_open = true;
}
}
TEST(LibRGW, PUT_OBJECT) {
if (do_put) {
size_t nbytes;
string data = "hi mom"; // fix this
int ret = rgw_write(fs, object_fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, data.length());
/* commit write transaction */
ret = rgw_close(fs, object_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, GET_OBJECT) {
if (do_get) {
char sbuf[512];
memset(sbuf, 0, 512);
size_t nread;
int ret = rgw_read(fs, object_fh, 0 /* off */, 512 /* len */, &nread, sbuf,
RGW_READ_FLAG_NONE);
ASSERT_EQ(ret, 0);
buffer::list bl;
bl.push_back(buffer::create_static(nread, sbuf));
if (do_hexdump) {
dout(15) << "";
bl.hexdump(*_dout);
*_dout << dendl;
}
}
}
TEST(LibRGW, STAT_OBJECT) {
if (do_stat) {
struct stat st;
int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
dout(15) << "rgw_getattr on " << object_name << " size = "
<< st.st_size << dendl;
}
}
TEST(LibRGW, WRITE_READ_VERIFY)
{
if (do_bulk && do_put) {
ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
struct iovec *iovs = zp_set1.get_iovs();
/* read after write POSIX-style */
size_t nbytes, off = 0;
for (int ix = 0; ix < 16; ++ix, off += page_size) {
struct iovec *iov = &iovs[ix];
int ret = rgw_write(fs, object_fh, off, page_size, &nbytes,
iov->iov_base, RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, size_t(page_size));
}
zp_set1.reset_iovs();
}
}
/* "functions that call alloca are not inlined"
* --alexandre oliva
* http://gcc.gnu.org/ml/gcc-help/2004-04/msg00158.html
*/
#define alloca_uio() \
do {\
int uiosz = sizeof(rgw_uio) + iovcnt*sizeof(rgw_vio); \
uio = static_cast<rgw_uio*>(alloca(uiosz)); \
memset(uio, 0, uiosz); \
uio->uio_vio = reinterpret_cast<rgw_vio*>(uio+sizeof(rgw_uio)); \
} while (0); \
TEST(LibRGW, WRITEV)
{
if (do_writev) {
rgw_uio* uio;
struct iovec *iovs = zp_set1.get_iovs();
alloca_uio();
ASSERT_NE(uio, nullptr);
for (int ix = 0; ix < iovcnt; ++ix) {
struct iovec *iov = &iovs[ix];
rgw_vio *vio = &(uio->uio_vio[ix]);
vio->vio_base = iov->iov_base;
vio->vio_len = iov->iov_len;
vio->vio_u1 = iov; // private data
}
uio->uio_cnt = iovcnt;
uio->uio_offset = iovcnt * page_size;
int ret = rgw_writev(fs, object_fh, uio, RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, READV)
{
if (do_readv) {
memset(uio, 0, sizeof(rgw_uio));
uio->uio_offset = 0; // ok, it was already 0
uio->uio_resid = UINT64_MAX;
int ret = rgw_readv(fs, object_fh, uio, RGW_READ_FLAG_NONE);
ASSERT_EQ(ret, 0);
buffer::list bl;
for (unsigned int ix = 0; ix < uio->uio_cnt; ++ix) {
rgw_vio *vio = &(uio->uio_vio[ix]);
bl.push_back(
buffer::create_static(vio->vio_len,
static_cast<char*>(vio->vio_base)));
}
/* length check */
ASSERT_EQ(uint32_t{bl.length()}, uint32_t{iovcnt*page_size});
if (do_hexdump) {
dout(15) << "";
bl.hexdump(*_dout);
*_dout << dendl;
}
}
}
TEST(LibRGW, READV_AFTER_WRITEV)
{
/* checksum data */
if (do_readv && do_writev && do_verify) {
ASSERT_TRUE(zp_set1 == uio);
}
}
TEST(LibRGW, DELETE_OBJECT) {
if (do_delete) {
int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, DELETE_BUCKET) {
if (do_delete) {
int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CLEANUP) {
if (do_readv) {
// release resources
ASSERT_NE(uio->uio_rele, nullptr);
if (uio->uio_rele) {
uio->uio_rele(uio, RGW_UIO_NONE);
}
}
int ret;
if (object_open) {
ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
if (object_fh) {
ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
uid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_flag(args, arg_iter, "--get",
(char*) nullptr)) {
do_get = true;
} else if (ceph_argparse_flag(args, arg_iter, "--stat",
(char*) nullptr)) {
do_stat = true;
} else if (ceph_argparse_flag(args, arg_iter, "--put",
(char*) nullptr)) {
do_put = true;
} else if (ceph_argparse_flag(args, arg_iter, "--bulk",
(char*) nullptr)) {
do_bulk = true;
} else if (ceph_argparse_flag(args, arg_iter, "--writev",
(char*) nullptr)) {
do_writev = true;
} else if (ceph_argparse_flag(args, arg_iter, "--readv",
(char*) nullptr)) {
do_readv = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verify",
(char*) nullptr)) {
do_verify = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--prelist",
(char*) nullptr)) {
do_pre_list = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 13,117 | 24.226923 | 80 |
cc
|
null |
ceph-main/src/test/librgw_file_marker.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <fstream>
#include <stack>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "rgw_file.h"
#include "rgw_lib_frontend.h" // direct requests
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "global/global_init.h"
#include "include/ceph_assert.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
using namespace rgw;
using std::get;
using std::string;
librgw_t rgw_h = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
CephContext* cct = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name("dmarker");
class obj_rec
{
public:
string name;
struct rgw_file_handle* fh;
struct rgw_file_handle* parent_fh;
RGWFileHandle* rgw_fh; // alias into fh
struct state {
bool readdir;
state() : readdir(false) {}
} state;
obj_rec(string _name, struct rgw_file_handle* _fh,
struct rgw_file_handle* _parent_fh, RGWFileHandle* _rgw_fh)
: name(std::move(_name)), fh(_fh), parent_fh(_parent_fh),
rgw_fh(_rgw_fh) {}
void clear() {
fh = nullptr;
rgw_fh = nullptr;
}
void sync() {
if (fh)
rgw_fh = get_rgwfh(fh);
}
friend ostream& operator<<(ostream& os, const obj_rec& rec);
};
/* Unused
ostream& operator<<(ostream& os, const obj_rec& rec)
{
RGWFileHandle* rgw_fh = rec.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rec.rgw_fh->full_object_name()
<< " (" << rec.rgw_fh->object_name() << "): "
<< type;
}
return os;
}
*/
std::stack<obj_rec> obj_stack;
std::deque<obj_rec> cleanup_queue;
typedef std::vector<obj_rec> obj_vec;
typedef std::tuple<obj_rec, obj_vec> dirs1_rec;
typedef std::vector<dirs1_rec> dirs1_vec;
dirs1_vec dirs_vec;
struct obj_rec_st
{
const obj_rec& obj;
const struct stat& st;
obj_rec_st(const obj_rec& _obj, const struct stat& _st)
: obj(_obj), st(_st) {}
};
/* Unused
ostream& operator<<(ostream& os, const obj_rec_st& rec)
{
RGWFileHandle* rgw_fh = rec.obj.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rgw_fh->full_object_name()
<< " (" << rgw_fh->object_name() << "): "
<< type;
const struct stat& st = rec.st;
switch(uint8_t(rgw_fh->is_dir())) {
case 1:
os << " mode: " << st.st_mode;
os << " nlinks: " << st.st_nlink;
break;
case 0:
default:
os << " mode: " << st.st_mode;
os << " size: " << st.st_size;
// xxx
break;
}
}
return os;
}
*/
bool do_marker1 = false;
bool do_marker2 = true;
bool do_create = false;
bool do_delete = false;
bool verbose = false;
string marker_dir("nfs_marker");
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *marker_fh;
uint32_t marker_nobjs = 2*1024;
std::deque<obj_rec> marker_objs;
using dirent_t = std::tuple<std::string, uint64_t>;
struct dirent_vec
{
std::vector<dirent_t> obj_names;
uint32_t count;
dirent_vec() : count(0) {}
};
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, TVAR) {
typedef boost::variant<uint64_t*, const char*> readdir_offset;
uint64_t i1{64001};
std::string s1{"blunderbuss"};
readdir_offset v1{&i1};
readdir_offset v2{s1.c_str()};
readdir_offset v3{static_cast<const char*>(nullptr)};
uint64_t* pi1 = get<uint64_t*>(v1);
ASSERT_NE(pi1, nullptr);
std::cout << "read i1: " << *pi1 << std::endl;
const char* ps1 = get<const char*>(v2);
ASSERT_NE(ps1, nullptr);
std::cout << "read s1: " << ps1 << std::endl;
const char* ps3 = get<const char*>(v3);
ASSERT_EQ(ps3, nullptr);
std::cout << "read s3: " << ps3 << std::endl;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw_h, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw_h, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw_h, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
cct = static_cast<RGWLibFS*>(fs->fs_private)->get_context();
}
TEST(LibRGW, MARKER1_SETUP_BUCKET) {
/* "large" directory enumeration test. this one deals only with
* file objects */
struct stat st;
int ret;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
(void) rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! bucket_fh) {
if (do_create) {
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&bucket_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
ASSERT_NE(bucket_fh, nullptr);
(void) rgw_lookup(fs, bucket_fh, marker_dir.c_str(), &marker_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! marker_fh) {
if (do_create) {
ret = rgw_mkdir(fs, bucket_fh, marker_dir.c_str(), &st, create_mask,
&marker_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
ASSERT_NE(marker_fh, nullptr);
}
TEST(LibRGW, MARKER1_SETUP_OBJECTS)
{
/* "large" directory enumeration test. this one deals only with
* file objects */
if (do_create) {
int ret;
for (uint32_t ix = 0; ix < marker_nobjs; ++ix) {
std::string object_name("f_");
object_name += to_string(ix);
obj_rec obj{object_name, nullptr, marker_fh, nullptr};
// lookup object--all operations are by handle
ret = rgw_lookup(fs, marker_fh, obj.name.c_str(), &obj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
obj.rgw_fh = get_rgwfh(obj.fh);
// open object--open transaction
ret = rgw_open(fs, obj.fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_TRUE(obj.rgw_fh->is_open());
// unstable write data
size_t nbytes;
string data("data for ");
data += object_name;
int ret = rgw_write(fs, obj.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, data.length());
// commit transaction (write on close)
ret = rgw_close(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
if (verbose) {
/* XXX std:cout fragged...did it get /0 in the stream
* somewhere? */
printf("created: %s:%s\n", bucket_name.c_str(), obj.name.c_str());
}
// save for cleanup
marker_objs.push_back(obj);
}
}
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
dirent_vec& dvec =
*(static_cast<dirent_vec*>(arg));
printf("%s bucket=%s dir=%s iv count=%d called back name=%s flags=%d\n",
__func__,
bucket_name.c_str(),
marker_dir.c_str(),
dvec.count,
name,
flags);
string name_str{name};
if (! ((name_str == ".") ||
(name_str == ".."))) {
dvec.obj_names.push_back(dirent_t{std::move(name_str), offset});
}
return true; /* XXX */
}
}
TEST(LibRGW, MARKER1_READDIR)
{
if (do_marker1) {
using std::get;
dirent_vec dvec;
uint64_t offset = 0;
bool eof = false;
/* because RGWReaddirRequest::default_max is 1000 (XXX make
* configurable?) and marker_nobjs is 5*1024, the number
* of required rgw_readdir operations N should be
* marker_nobjs/1000 < N < marker_nobjs/1000+1, i.e., 6 when
* marker_nobjs==5*1024 */
uint32_t max_iterations = marker_nobjs/1000+1;
do {
ASSERT_TRUE(dvec.count <= max_iterations);
int ret = rgw_readdir(fs, marker_fh, &offset, r2_cb, &dvec, &eof,
RGW_READDIR_FLAG_DOTDOT);
ASSERT_EQ(ret, 0);
ASSERT_GE(dvec.obj_names.size(), 0);
ASSERT_EQ(offset, get<1>(dvec.obj_names.back())); // cookie check
++dvec.count;
} while(!eof);
std::cout << "Read " << dvec.obj_names.size() << " objects in "
<< marker_dir.c_str() << std::endl;
}
}
TEST(LibRGW, MARKER2_READDIR)
{
if (do_marker2) {
using std::get;
dirent_vec dvec;
std::string marker{""};
bool eof = false;
/* because RGWReaddirRequest::default_max is 1000 (XXX make
* configurable?) and marker_nobjs is 5*1024, the number
* of required rgw_readdir operations N should be
* marker_nobjs/1000 < N < marker_nobjs/1000+1, i.e., 6 when
* marker_nobjs==5*1024 */
uint32_t max_iterations = marker_nobjs/1000+1;
do {
ASSERT_TRUE(dvec.count <= max_iterations);
int ret = rgw_readdir2(fs, marker_fh,
(marker.length() > 0) ? marker.c_str() : nullptr,
r2_cb, &dvec, &eof,
RGW_READDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_GE(dvec.obj_names.size(), 0);
marker = get<0>(dvec.obj_names.back());
++dvec.count;
} while((!eof) && dvec.count < 4);
std::cout << "Read " << dvec.obj_names.size() << " objects in "
<< marker_dir.c_str() << std::endl;
}
}
TEST(LibRGW, MARKER1_OBJ_CLEANUP)
{
int rc;
for (auto& obj : marker_objs) {
if (obj.fh) {
if (do_delete) {
if (verbose) {
std::cout << "unlinking: " << bucket_name << ":" << obj.name
<< std::endl;
}
rc = rgw_unlink(fs, marker_fh, obj.name.c_str(), RGW_UNLINK_FLAG_NONE);
}
rc = rgw_fh_rele(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
marker_objs.clear();
}
TEST(LibRGW, CLEANUP) {
int rc;
if (do_marker1) {
cleanup_queue.push_back(
obj_rec{bucket_name, bucket_fh, fs->root_fh, get_rgwfh(fs->root_fh)});
}
for (auto& elt : cleanup_queue) {
if (elt.fh) {
rc = rgw_fh_rele(fs, elt.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
cleanup_queue.clear();
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw_h);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--nobjs",
(char*) nullptr)) {
marker_nobjs = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--marker1",
(char*) nullptr)) {
do_marker1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 12,713 | 24.633065 | 78 |
cc
|
null |
ceph-main/src/test/librgw_file_nfsns.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <fstream>
#include <stack>
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "rgw_file.h"
#include "rgw_lib.h"
#include "rgw_lib_frontend.h" // direct requests
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "include/ceph_assert.h"
#define dout_subsys ceph_subsys_rgw
using namespace std;
using namespace rgw; // g_rgwlib
namespace {
using namespace rgw;
using std::get;
using std::string;
librgw_t rgw_h = nullptr;
string userid("testuser");
string access_key("");
string secret_key("");
struct rgw_fs *fs = nullptr;
CephContext* cct = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t magic_uid = 1701;
uint32_t magic_gid = 9876;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name("nfsroot");
string dirs1_bucket_name("bdirs1");
string readf_name("toyland");
string readf_out_name("rgwlib_readf.out");
std::string writef_name{"bigbird"};
int n_dirs1_dirs = 3;
int n_dirs1_objs = 2;
class obj_rec
{
public:
string name;
struct rgw_file_handle* fh;
struct rgw_file_handle* parent_fh;
RGWFileHandle* rgw_fh; // alias into fh
struct state {
bool readdir;
state() : readdir(false) {}
} state;
obj_rec(string _name, struct rgw_file_handle* _fh,
struct rgw_file_handle* _parent_fh, RGWFileHandle* _rgw_fh)
: name(std::move(_name)), fh(_fh), parent_fh(_parent_fh),
rgw_fh(_rgw_fh) {}
void clear() {
fh = nullptr;
rgw_fh = nullptr;
}
void sync() {
if (fh)
rgw_fh = get_rgwfh(fh);
}
friend ostream& operator<<(ostream& os, const obj_rec& rec);
};
ostream& operator<<(ostream& os, const obj_rec& rec)
{
RGWFileHandle* rgw_fh = rec.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rec.rgw_fh->full_object_name()
<< " (" << rec.rgw_fh->object_name() << "): "
<< type;
}
return os;
}
std::stack<obj_rec> obj_stack;
std::deque<obj_rec> cleanup_queue;
typedef std::vector<obj_rec> obj_vec;
typedef std::tuple<obj_rec, obj_vec> dirs1_rec;
typedef std::vector<dirs1_rec> dirs1_vec;
dirs1_vec dirs_vec;
struct obj_rec_st
{
const obj_rec& obj;
const struct stat& st;
obj_rec_st(const obj_rec& _obj, const struct stat& _st)
: obj(_obj), st(_st) {}
};
ostream& operator<<(ostream& os, const obj_rec_st& rec)
{
RGWFileHandle* rgw_fh = rec.obj.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rgw_fh->full_object_name()
<< " (" << rgw_fh->object_name() << "): "
<< type;
const struct stat& st = rec.st;
switch(uint8_t(rgw_fh->is_dir())) {
case 1:
os << " mode: " << st.st_mode;
os << " nlinks: " << st.st_nlink;
break;
case 0:
default:
os << " mode: " << st.st_mode;
os << " size: " << st.st_size;
// xxx
break;
}
}
return os;
}
bool do_hier1 = false;
bool do_dirs1 = false;
bool do_readf = false;
bool do_writef = false;
bool do_marker1 = false;
bool do_create = false;
bool do_delete = false;
bool do_rename = false;
bool do_setattr = false;
bool verbose = false;
string marker_dir("nfs_marker");
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *marker_fh;
static constexpr int marker_nobjs = 2*1024;
std::deque<obj_rec> marker_objs;
using dirent_t = std::tuple<std::string, uint64_t>;
struct dirent_vec
{
std::vector<dirent_t> obj_names;
uint32_t count;
dirent_vec() : count(0) {}
};
obj_rec dirs1_b{dirs1_bucket_name, nullptr, nullptr, nullptr};
dirs1_vec renames_vec;
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw_h, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw_h, nullptr);
}
TEST(LibRGW, MOUNT_NOROOT) {
/* do a mount at root="" and verify that it's root is "/" */
struct rgw_fs *fs = nullptr;
int ret = rgw_mount2(rgw_h, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
auto& root_fh = static_cast<RGWLibFS*>(fs->fs_private)->get_fh();
ASSERT_EQ(root_fh.get_name(), "/");
ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount2(rgw_h, userid.c_str(), access_key.c_str(),
secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
cct = static_cast<RGWLibFS*>(fs->fs_private)->get_context();
}
TEST(LibRGW, SETUP_HIER1)
{
if (do_hier1) {
(void) rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! bucket_fh) {
if (do_create) {
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int rc = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st,
create_mask, &bucket_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(bucket_fh, nullptr);
if (do_create) {
/* create objects directly */
std::vector<std::string> obj_names =
{"foo/bar/baz/quux",
"foo/f1",
"foo/f2",
"foo/bar/f1",
"foo/bar/d1/",
"foo/bar/baz/hungry",
"foo/bar/baz/hungry/",
"foo/bar/baz/momma",
"foo/bar/baz/bear/",
"foo/bar/baz/sasquatch",
"foo/bar/baz/sasquatch/",
"foo/bar/baz/frobozz"};
buffer::list bl; // empty object
RGWLibFS *fs_private = static_cast<RGWLibFS*>(fs->fs_private);
for (const auto& obj_name : obj_names) {
if (verbose) {
std::cout << "creating: " << bucket_name << ":" << obj_name
<< std::endl;
}
RGWPutObjRequest req(cct,
g_rgwlib->get_driver()->get_user(fs_private->get_user()->user_id),
bucket_name, obj_name, bl);
int rc = g_rgwlib->get_fe()->execute_req(&req);
int rc2 = req.get_ret();
ASSERT_EQ(rc, 0);
ASSERT_EQ(rc2, 0);
}
}
}
}
TEST(LibRGW, SETUP_DIRS1) {
if (do_dirs1) {
int rc;
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
dirs1_b.parent_fh = fs->root_fh;
(void) rgw_lookup(fs, dirs1_b.parent_fh, dirs1_bucket_name.c_str(),
&dirs1_b.fh, nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! dirs1_b.fh) {
if (do_create) {
rc = rgw_mkdir(fs, dirs1_b.parent_fh, dirs1_b.name.c_str(), &st,
create_mask, &dirs1_b.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
} else {
/* no top-level dir and can't create it--skip remaining tests */
return;
}
}
dirs1_b.sync();
/* make top-level dirs */
int d_ix;
obj_vec ovec;
for (d_ix = 0; d_ix < n_dirs1_dirs; ++d_ix) {
std::string dname{"dir_"};
dname += to_string(d_ix);
obj_rec dir{dname, nullptr, dirs1_b.fh, nullptr};
ovec.clear();
(void) rgw_lookup(fs, dir.parent_fh, dir.name.c_str(), &dir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! dir.fh) {
if (do_create) {
rc = rgw_mkdir(fs, dir.parent_fh, dir.name.c_str(), &st, create_mask,
&dir.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(dir.fh, nullptr);
dir.sync();
ASSERT_NE(dir.rgw_fh, nullptr);
ASSERT_TRUE(dir.rgw_fh->is_dir());
int f_ix;
for (f_ix = 0; f_ix < n_dirs1_objs; ++f_ix) {
/* child dir */
std::string sdname{"sdir_"};
sdname += to_string(f_ix);
obj_rec sdir{sdname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sdir.parent_fh, sdir.name.c_str(), &sdir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sdir.fh) {
if (do_create) {
rc = rgw_mkdir(fs, sdir.parent_fh, sdir.name.c_str(), &st,
create_mask, &sdir.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(sdir.fh, nullptr); // suppress !lookup && !create case
sdir.sync();
ASSERT_TRUE(sdir.rgw_fh->is_dir());
ovec.push_back(sdir);
/* child file */
std::string sfname{"sfile_"};
sfname += to_string(f_ix);
obj_rec sf{sfname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sf.fh) {
if (do_create) {
/* make a new file object (the hard way) */
rc = rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(rc, 0);
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
/* because we made it the hard way, fixup attributes */
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 644;
sf.rgw_fh->create_stat(&st, create_mask);
/* open handle */
rc = rgw_open(fs, sf.fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(sf.rgw_fh->is_open());
/* stage seq write */
size_t nbytes;
string data = "data for " + sf.name;
rc = rgw_write(fs, sf.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nbytes, data.length());
/* commit write transaction */
rc = rgw_close(fs, sf.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
} else {
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
}
if (sf.fh)
ovec.push_back(sf);
}
dirs_vec.push_back(dirs1_rec{dir, ovec});
}
} /* dirs1 top-level !exist */
}
TEST(LibRGW, SETATTR) {
if (do_dirs1) {
if (do_setattr) {
int rc;
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
std::string dname{"dir_0"};
obj_rec dir{dname, nullptr, dirs1_b.fh, nullptr};
/* dir_0 MUST exist and MUST be resident */
(void) rgw_lookup(fs, dir.parent_fh, dir.name.c_str(), &dir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_NE(dir.fh, nullptr);
dir.sync();
ASSERT_NE(dir.rgw_fh, nullptr);
ASSERT_TRUE(dir.rgw_fh->is_dir());
/* child file */
std::string sfname{"setattr_file_0"};
obj_rec sf{sfname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sf.fh) {
/* make a new file object (the hard way) */
rc = rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(rc, 0);
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
/* because we made it the hard way, fixup attributes */
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 644;
sf.rgw_fh->create_stat(&st, create_mask);
/* open handle */
rc = rgw_open(fs, sf.fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(sf.rgw_fh->is_open());
/* stage seq write */
size_t nbytes;
string data = "data for " + sf.name;
rc = rgw_write(fs, sf.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nbytes, data.length());
/* commit write transaction */
rc = rgw_close(fs, sf.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
} else {
sf.sync();
ASSERT_TRUE(sf.rgw_fh->is_file());
}
/* sf MUST now be materialized--now change it's attributes */
st.st_uid = magic_uid;
st.st_gid = magic_gid;
rc = rgw_setattr(fs, sf.fh, &st, create_mask, RGW_SETATTR_FLAG_NONE);
ASSERT_EQ(rc, 0);
/* force evict--subsequent lookups must reload */
static_cast<RGWLibFS*>(fs->fs_private)->release_evict(sf.rgw_fh);
sf.clear();
/* revalidate -- expect magic uid and gid */
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
sf.sync();
ASSERT_NE(sf.fh, nullptr);
memset(&st, 0, sizeof(struct stat)); /* nothing up my sleeve... */
rc = rgw_getattr(fs, sf.fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(st.st_uid, magic_uid);
ASSERT_EQ(st.st_gid, magic_gid);
/* release 1 ref on sf */
rgw_fh_rele(fs, sf.fh, RGW_FH_RELE_FLAG_NONE);
/* release 1 ref on dir */
rgw_fh_rele(fs, dir.fh, RGW_FH_RELE_FLAG_NONE);
} /* dirs1 */
}
}
TEST(LibRGW, RGW_CREATE_DIRS1) {
/* verify rgw_create (create [empty] file objects the easy way) */
if (do_dirs1) {
if (do_create) {
int rc;
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 644;
for (auto& dirs_rec : dirs_vec) {
/* create 1 more file in each sdir */
obj_rec& dir = get<0>(dirs_rec);
std::string sfname{"sfile_" + to_string(n_dirs1_objs)};
obj_rec sf{sfname, nullptr, dir.fh, nullptr};
(void) rgw_lookup(fs, sf.parent_fh, sf.name.c_str(), &sf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! sf.fh) {
rc = rgw_create(fs, sf.parent_fh, sf.name.c_str(), &st, create_mask,
&sf.fh, 0 /* posix flags */, RGW_CREATE_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
sf.sync();
}
n_dirs1_objs++;
}
}
}
TEST(LibRGW, RGW_SETUP_RENAME1) {
/* verify rgw_create (create [empty] file objects the easy way) */
if (do_rename) {
int rc;
struct stat st;
obj_vec ovec;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
for (int b_ix : {0, 1}) {
std::string bname{"brename" + to_string(b_ix)};
obj_rec brec{bname, nullptr, nullptr, nullptr};
(void) rgw_lookup(fs, fs->root_fh, brec.name.c_str(), &brec.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! brec.fh) {
if (do_create) {
struct stat st;
int rc = rgw_mkdir(fs, fs->root_fh, brec.name.c_str(), &st,
create_mask, &brec.fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(brec.fh, nullptr);
brec.sync();
st.st_mode = 644; /* file mask */
for (int f_ix : {0, 1}) {
std::string rfname{"rfile_"};
rfname += to_string(f_ix);
obj_rec rf{rfname, nullptr, brec.fh, nullptr};
(void) rgw_lookup(fs, rf.parent_fh, rf.name.c_str(), &rf.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! rf.fh) {
rc = rgw_create(fs, rf.parent_fh, rf.name.c_str(), &st, create_mask,
&rf.fh, 0 /* posix flags */, RGW_CREATE_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
rf.sync();
ovec.push_back(rf);
}
renames_vec.push_back(dirs1_rec{brec, ovec});
ovec.clear();
} /* b_ix */
}
}
TEST(LibRGW, RGW_INTRABUCKET_RENAME1) {
/* rgw_rename a file within a bucket */
if (do_rename) {
int rc;
obj_rec& bdir0 = get<0>(renames_vec[0]);
obj_rec& src_obj = get<1>(renames_vec[0])[0];
std::string rfname{"rfile_r0"};
if (verbose) {
std::cout << "rename file " << src_obj.name << " to "
<< rfname << " (bucket " << bdir0.name << ")"
<< std::endl;
}
rc = rgw_rename(fs, bdir0.fh, src_obj.name.c_str(), bdir0.fh,
rfname.c_str(), RGW_RENAME_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
TEST(LibRGW, RGW_CROSSBUCKET_RENAME1) {
/* rgw_rename a file within a bucket */
if (do_rename) {
int rc;
obj_rec& bdir0 = get<0>(renames_vec[0]);
obj_rec& bdir1 = get<0>(renames_vec[1]);
obj_rec& src_obj = get<1>(renames_vec[0])[1];
std::string rfname{"rfile_rhilldog"};
if (verbose) {
std::cout << "rename file " << src_obj.name
<< " (bucket " << bdir0.name << ") to "
<< rfname << " (bucket " << bdir1.name << ")"
<< std::endl;
}
rc = rgw_rename(fs, bdir0.fh, src_obj.name.c_str(), bdir1.fh,
rfname.c_str(), RGW_RENAME_FLAG_NONE);
ASSERT_EQ(rc, 0);
}
}
#if 0 /* XXX inconsistent failure here */
TEST(LibRGW, BAD_DELETES_DIRS1) {
if (do_dirs1) {
int rc;
if (dirs_vec.size() == 0) {
/* skip */
return;
}
if (do_delete) {
/* try to unlink a non-empty directory (bucket) */
rc = rgw_unlink(fs, dirs1_b.parent_fh, dirs1_b.name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_NE(rc, 0);
}
/* try to unlink a non-empty directory (non-bucket) */
obj_rec& sdir_0 = get<1>(dirs_vec[0])[0];
ASSERT_EQ(sdir_0.name, "sdir_0");
ASSERT_TRUE(sdir_0.rgw_fh->is_dir());
/* XXX we can't enforce this currently */
#if 0
ASSERT_EQ(sdir_0.name, "sdir_0");
ASSERT_TRUE(sdir_0.rgw_fh->is_dir());
rc = rgw_unlink(fs, sdir_0.parent_fh, sdir_0.name.c_str(),
RGW_UNLINK_FLAG_NONE);
ASSERT_NE(rc, 0);
#endif
}
}
#endif
TEST(LibRGW, GETATTR_DIRS1)
{
if (do_dirs1) {
int rc;
struct stat st;
for (auto& dirs_rec : dirs_vec) {
obj_rec& dir = get<0>(dirs_rec);
if (verbose) {
std::cout << "scanning objects in "
<< dir.rgw_fh->full_object_name()
<< std::endl;
}
for (auto& sobj : get<1>(dirs_rec)) {
rc = rgw_getattr(fs, sobj.fh, &st, RGW_GETATTR_FLAG_NONE);
ASSERT_EQ(rc, 0);
/* validate, pretty-print */
if (sobj.rgw_fh->object_name().find("sfile") != std::string::npos) {
ASSERT_TRUE(sobj.rgw_fh->is_file());
ASSERT_TRUE(S_ISREG(st.st_mode));
}
if (sobj.rgw_fh->object_name().find("sdir") != std::string::npos) {
ASSERT_TRUE(sobj.rgw_fh->is_dir());
ASSERT_TRUE(S_ISDIR(st.st_mode));
}
/* validate Unix owners */
ASSERT_EQ(st.st_uid, owner_uid);
ASSERT_EQ(st.st_gid, owner_gid);
if (verbose) {
obj_rec_st rec_st{sobj, st};
std::cout << "\t"
<< rec_st
<< std::endl;
}
}
}
}
}
TEST(LibRGW, READ_DIRS1)
{
if (do_dirs1) {
int rc;
char buf[256];
size_t nread;
for (auto& dirs_rec : dirs_vec) {
obj_rec& dir = get<0>(dirs_rec);
if (verbose) {
std::cout << "read back objects in "
<< dir.rgw_fh->full_object_name()
<< std::endl;
}
for (auto& sobj : get<1>(dirs_rec)) {
/* only the first 2 file objects have data */
if ((sobj.rgw_fh->object_name().find("sfile_0")
!= std::string::npos) ||
(sobj.rgw_fh->object_name().find("sfile_1")
!= std::string::npos)) {
ASSERT_TRUE(sobj.rgw_fh->is_file());
ASSERT_EQ(sobj.rgw_fh->get_size(), 16UL);
// do it
memset(buf, 0, 256);
if (verbose) {
std::cout << "reading 0,256 " << sobj.rgw_fh->relative_object_name()
<< std::endl;
}
rc = rgw_read(fs, sobj.fh, 0, 256, &nread, buf, RGW_READ_FLAG_NONE);
ASSERT_EQ(rc, 0);
if (verbose) {
std::cout << "\tread back from " << sobj.name
<< " : \"" << buf << "\""
<< std::endl;
}
}
}
}
}
}
TEST(LibRGW, READF_SETUP1)
{
struct stat st;
if (do_dirs1) {
if (do_create) {
if ((! stat(readf_out_name.c_str(), &st)) &&
(S_ISREG(st.st_mode)) &&
(st.st_size == 6291456))
return;
ofstream of;
of.open(readf_out_name, ios::out|ios::app|ios::binary);
for (int ix1 = 0; ix1 < 6; ++ix1) {
for (int ix2 = 0; ix2 < 1024*1024; ++ix2) {
of << ix1;
}
}
}
}
}
TEST(LibRGW, READF_DIRS1) {
if (do_dirs1) {
if (do_readf) {
obj_rec fobj{readf_name, nullptr, dirs1_b.fh, nullptr};
int rc = rgw_lookup(fs, dirs1_b.fh, fobj.name.c_str(), &fobj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_NE(fobj.fh, nullptr);
fobj.sync();
ofstream of;
of.open(readf_out_name, ios::out|ios::app|ios::binary);
int bufsz = 1024 * 1024 * sizeof(char);
auto buffer = std::make_unique<char[]>(bufsz);
uint64_t offset = 0;
uint64_t length = bufsz;
for (int ix = 0; ix < 6; ++ix) {
size_t nread = 0;
memset(buffer.get(), 0, length); // XXX
rc = rgw_read(fs, fobj.fh, offset, length, &nread, buffer.get(),
RGW_READ_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nread, length);
of.write(buffer.get(), length);
offset += nread;
}
of.close();
rgw_fh_rele(fs, fobj.fh, 0 /* flags */);
}
}
}
TEST(LibRGW, WRITEF_DIRS1) {
if (do_dirs1) {
if (do_writef) {
int rc;
ifstream ifs;
ifs.open(readf_out_name, ios::out|ios::app|ios::binary);
ASSERT_TRUE(ifs.is_open());
obj_rec fobj{writef_name, nullptr, dirs1_b.fh, nullptr};
(void) rgw_lookup(fs, fobj.parent_fh, fobj.name.c_str(), &fobj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
if (! fobj.fh) {
if (do_create) {
/* make a new file object (the hard way) */
rc = rgw_lookup(fs, fobj.parent_fh, fobj.name.c_str(), &fobj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(rc, 0);
}
}
ASSERT_NE(fobj.fh, nullptr);
fobj.sync();
/* begin write transaction */
rc = rgw_open(fs, fobj.fh, 0 /* posix flags */, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(fobj.rgw_fh->is_open());
int bufsz = 1024 * 1024 * sizeof(char);
char *buffer = (char*) malloc(bufsz);
uint64_t offset = 0;
uint64_t length = bufsz;
for (int ix = 0; ix < 6; ++ix) {
ASSERT_TRUE(ifs.good());
ifs.read(buffer, bufsz);
size_t nwritten = 0;
string str;
str.assign(buffer, 4);
if (verbose) {
std::cout << "read and writing " << length << " bytes"
<< " from " << readf_out_name
<< " at offset " << offset
<< " (" << str << "... [first 4 chars])"
<< std::endl;
}
char* leakbuf = (char*) malloc(bufsz);
memcpy(leakbuf, buffer, length);
rc = rgw_write(fs, fobj.fh, offset, length, &nwritten, leakbuf,
RGW_WRITE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ASSERT_EQ(nwritten, length);
offset += length;
}
/* commit write transaction */
rc = rgw_close(fs, fobj.fh, RGW_CLOSE_FLAG_NONE);
ASSERT_EQ(rc, 0);
ifs.close();
free(buffer);
rgw_fh_rele(fs, fobj.fh, 0 /* flags */);
}
}
}
TEST(LibRGW, RELEASE_DIRS1) {
if (do_dirs1) {
/* force release of handles for children of dirs1--force subsequent
* checks to reload them from the cluster.
*
* while doing this, verify handle cleanup and correct LRU state
* (not reachable)
*/
int rc;
for (auto& dirs_rec : dirs_vec) {
for (auto& obj : get<1>(dirs_rec)) {
if (verbose) {
std::cout << "release " << obj.name
<< " type: " << obj.rgw_fh->stype()
<< " refs: " << obj.rgw_fh->get_refcnt()
<< std::endl;
}
ASSERT_EQ(obj.rgw_fh->get_refcnt(), 2UL);
rc = rgw_fh_rele(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
ASSERT_EQ(obj.rgw_fh->get_refcnt(), 1UL);
/* try-discard handle */
/* clear obj_rec vec */
}
}
}
}
extern "C" {
static int r1_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
struct rgw_file_handle* parent_fh
= static_cast<struct rgw_file_handle*>(arg);
RGWFileHandle* rgw_fh = get_rgwfh(parent_fh);
lsubdout(cct, rgw, 10) << __func__
<< " bucket=" << rgw_fh->bucket_name()
<< " dir=" << rgw_fh->full_object_name()
<< " called back name=" << name
<< " flags=" << flags
<< dendl;
string name_str{name};
if (! ((name_str == ".") ||
(name_str == ".."))) {
obj_stack.push(
obj_rec{std::move(name_str), nullptr, parent_fh, nullptr});
}
return true; /* XXX */
}
}
TEST(LibRGW, HIER1) {
if (do_hier1) {
int rc;
obj_stack.push(
obj_rec{bucket_name, nullptr, nullptr, nullptr});
while (! obj_stack.empty()) {
auto& elt = obj_stack.top();
if (! elt.fh) {
struct rgw_file_handle* parent_fh = elt.parent_fh
? elt.parent_fh : fs->root_fh;
RGWFileHandle* pfh = get_rgwfh(parent_fh);
rgw::ignore(pfh);
lsubdout(cct, rgw, 10)
<< "rgw_lookup:"
<< " parent object_name()=" << pfh->object_name()
<< " parent full_object_name()=" << pfh->full_object_name()
<< " elt.name=" << elt.name
<< dendl;
rc = rgw_lookup(fs, parent_fh, elt.name.c_str(), &elt.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(rc, 0);
// XXXX
RGWFileHandle* efh = get_rgwfh(elt.fh);
rgw::ignore(efh);
lsubdout(cct, rgw, 10)
<< "rgw_lookup result:"
<< " elt object_name()=" << efh->object_name()
<< " elt full_object_name()=" << efh->full_object_name()
<< " elt.name=" << elt.name
<< dendl;
ASSERT_NE(elt.fh, nullptr);
elt.rgw_fh = get_rgwfh(elt.fh);
elt.parent_fh = elt.rgw_fh->get_parent()->get_fh();
ASSERT_EQ(elt.parent_fh, parent_fh);
continue;
} else {
// we have a handle in some state in top position
switch(elt.fh->fh_type) {
case RGW_FS_TYPE_DIRECTORY:
if (! elt.state.readdir) {
// descending
uint64_t offset = 0;
bool eof; // XXX
lsubdout(cct, rgw, 10)
<< "readdir in"
<< " bucket: " << elt.rgw_fh->bucket_name()
<< " object_name: " << elt.rgw_fh->object_name()
<< " full_name: " << elt.rgw_fh->full_object_name()
<< dendl;
rc = rgw_readdir(fs, elt.fh, &offset, r1_cb, elt.fh, &eof,
RGW_READDIR_FLAG_DOTDOT);
elt.state.readdir = true;
ASSERT_EQ(rc, 0);
// ASSERT_TRUE(eof); // XXXX working incorrectly w/single readdir
} else {
// ascending
std::cout << elt << std::endl;
cleanup_queue.push_back(elt);
obj_stack.pop();
}
break;
case RGW_FS_TYPE_FILE:
// ascending
std::cout << elt << std::endl;
cleanup_queue.push_back(elt);
obj_stack.pop();
break;
default:
ceph_abort();
};
}
}
}
}
TEST(LibRGW, MARKER1_SETUP_BUCKET) {
/* "large" directory enumeration test. this one deals only with
* file objects */
if (do_marker1) {
struct stat st;
int ret;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
if (do_create) {
ret = rgw_mkdir(fs, bucket_fh, marker_dir.c_str(), &st, create_mask,
&marker_fh, RGW_MKDIR_FLAG_NONE);
} else {
ret = rgw_lookup(fs, bucket_fh, marker_dir.c_str(), &marker_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
}
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, MARKER1_SETUP_OBJECTS)
{
/* "large" directory enumeration test. this one deals only with
* file objects */
if (do_marker1 && do_create) {
int ret;
for (int ix = 0; ix < marker_nobjs; ++ix) {
std::string object_name("f_");
object_name += to_string(ix);
obj_rec obj{object_name, nullptr, marker_fh, nullptr};
// lookup object--all operations are by handle
ret = rgw_lookup(fs, marker_fh, obj.name.c_str(), &obj.fh,
nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
ASSERT_EQ(ret, 0);
obj.rgw_fh = get_rgwfh(obj.fh);
// open object--open transaction
ret = rgw_open(fs, obj.fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_TRUE(obj.rgw_fh->is_open());
// unstable write data
size_t nbytes;
string data("data for ");
data += object_name;
int ret = rgw_write(fs, obj.fh, 0, data.length(), &nbytes,
(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(nbytes, data.length());
// commit transaction (write on close)
ret = rgw_close(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
// save for cleanup
marker_objs.push_back(obj);
}
}
}
extern "C" {
static int r2_cb(const char* name, void *arg, uint64_t offset,
struct stat* st, uint32_t st_mask,
uint32_t flags) {
dirent_vec& dvec =
*(static_cast<dirent_vec*>(arg));
lsubdout(cct, rgw, 10) << __func__
<< " bucket=" << bucket_name
<< " dir=" << marker_dir
<< " iv count=" << dvec.count
<< " called back name=" << name
<< " flags=" << flags
<< dendl;
string name_str{name};
if (! ((name_str == ".") ||
(name_str == ".."))) {
dvec.obj_names.push_back(dirent_t{std::move(name_str), offset});
}
return true; /* XXX */
}
}
TEST(LibRGW, MARKER1_READDIR)
{
if (do_marker1) {
using std::get;
dirent_vec dvec;
uint64_t offset = 0;
bool eof = false;
/* because RGWReaddirRequest::default_max is 1000 (XXX make
* configurable?) and marker_nobjs is 5*1024, the number
* of required rgw_readdir operations N should be
* marker_nobjs/1000 < N < marker_nobjs/1000+1, i.e., 6 when
* marker_nobjs==5*1024 */
uint32_t max_iterations = marker_nobjs/1000+1;
do {
ASSERT_TRUE(dvec.count <= max_iterations);
int ret = rgw_readdir(fs, marker_fh, &offset, r2_cb, &dvec, &eof,
RGW_READDIR_FLAG_DOTDOT);
ASSERT_EQ(ret, 0);
ASSERT_EQ(offset, get<1>(dvec.obj_names.back())); // cookie check
++dvec.count;
} while(!eof);
std::cout << "Read " << dvec.obj_names.size() << " objects in "
<< marker_dir.c_str() << std::endl;
}
}
TEST(LibRGW, MARKER1_OBJ_CLEANUP)
{
int rc;
for (auto& obj : marker_objs) {
if (obj.fh) {
if (do_delete) {
if (verbose) {
std::cout << "unlinking: " << bucket_name << ":" << obj.name
<< std::endl;
}
rc = rgw_unlink(fs, marker_fh, obj.name.c_str(), RGW_UNLINK_FLAG_NONE);
}
rc = rgw_fh_rele(fs, obj.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
marker_objs.clear();
}
TEST(LibRGW, CLEANUP) {
int rc;
if (do_marker1) {
cleanup_queue.push_back(
obj_rec{bucket_name, bucket_fh, fs->root_fh, get_rgwfh(fs->root_fh)});
}
for (auto& elt : cleanup_queue) {
if (elt.fh) {
rc = rgw_fh_rele(fs, elt.fh, 0 /* flags */);
ASSERT_EQ(rc, 0);
}
}
cleanup_queue.clear();
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw_h);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
(char*) nullptr)) {
userid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
owner_uid = std::stoi(val);
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
(char*) nullptr)) {
owner_gid = std::stoi(val);
} else if (ceph_argparse_flag(args, arg_iter, "--hier1",
(char*) nullptr)) {
do_hier1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--dirs1",
(char*) nullptr)) {
do_dirs1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--marker1",
(char*) nullptr)) {
do_marker1 = true;
} else if (ceph_argparse_flag(args, arg_iter, "--setattr",
(char*) nullptr)) {
do_setattr = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--rename",
(char*) nullptr)) {
do_rename = true;
} else if (ceph_argparse_flag(args, arg_iter, "--readf",
(char*) nullptr)) {
do_readf = true;
} else if (ceph_argparse_flag(args, arg_iter, "--writef",
(char*) nullptr)) {
do_writef = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
/* don't accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 32,378 | 25.649383 | 78 |
cc
|
null |
ceph-main/src/test/librgw_file_xattr.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2015 Red Hat, Inc.
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include <boost/algorithm/string.hpp>
#include "xxhash.h"
#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"
#include "rgw_file.h"
#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/errno.h"
#include "common/debug.h"
#include "global/global_init.h"
#include "include/ceph_assert.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw
using namespace std;
namespace {
using namespace rgw;
string uid("testuser");
string access_key("");
string secret_key("");
librgw_t rgw_h = nullptr;
struct rgw_fs *fs = nullptr;
uint32_t owner_uid = 867;
uint32_t owner_gid = 5309;
uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;
string bucket_name{"v4recov"};
string object_path{"node0/clientids"};
string key1{"black"};
string val1{"metallic"};
struct rgw_file_handle *bucket_fh = nullptr;
struct rgw_file_handle *object_fh = nullptr;
typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
std::vector<fid_type> fids;
class obj_rec
{
public:
string name;
struct rgw_file_handle* fh;
struct rgw_file_handle* parent_fh;
RGWFileHandle* rgw_fh; // alias into fh
struct state {
bool readdir;
state() : readdir(false) {}
} state;
obj_rec(string _name, struct rgw_file_handle* _fh,
struct rgw_file_handle* _parent_fh, RGWFileHandle* _rgw_fh)
: name(std::move(_name)), fh(_fh), parent_fh(_parent_fh),
rgw_fh(_rgw_fh) {}
void clear() {
fh = nullptr;
rgw_fh = nullptr;
}
void sync() {
if (fh)
rgw_fh = get_rgwfh(fh);
}
friend ostream& operator<<(ostream& os, const obj_rec& rec);
};
[[maybe_unused]] ostream& operator<<(ostream& os, const obj_rec& rec)
{
RGWFileHandle* rgw_fh = rec.rgw_fh;
if (rgw_fh) {
const char* type = rgw_fh->is_dir() ? "DIR " : "FILE ";
os << rec.rgw_fh->full_object_name()
<< " (" << rec.rgw_fh->object_name() << "): "
<< type;
}
return os;
}
typedef std::vector<obj_rec> obj_vec;
obj_vec ovec;
bool do_stat = false;
bool do_create = false;
bool do_delete = false;
bool do_hexdump = false;
bool verbose = false;
struct {
int argc;
char **argv;
} saved_args;
}
TEST(LibRGW, INIT) {
int ret = librgw_create(&rgw_h, saved_args.argc, saved_args.argv);
ASSERT_EQ(ret, 0);
ASSERT_NE(rgw_h, nullptr);
}
TEST(LibRGW, MOUNT) {
int ret = rgw_mount(rgw_h, uid.c_str(), access_key.c_str(),
secret_key.c_str(), &fs, RGW_MOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
ASSERT_NE(fs, nullptr);
}
TEST(LibRGW, LOOKUP_BUCKET) {
int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, CREATE_BUCKET) {
if ((! bucket_fh) && do_create) {
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
&bucket_fh, RGW_MKDIR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
}
TEST(LibRGW, CREATE_PATH) {
if (!bucket_fh)
return;
vector<string> segs;
boost::split(segs, object_path, boost::is_any_of("/"));
struct stat st;
st.st_uid = owner_uid;
st.st_gid = owner_gid;
st.st_mode = 755;
int ix, ret, sz = segs.size();
for (ix = 0; ix < sz; ++ix) {
auto& seg = segs[ix];
struct rgw_file_handle* parent_fh = (ix > 0) ? ovec[ix-1].fh : bucket_fh;
obj_rec dir{seg, nullptr, parent_fh, nullptr};
if (do_create) {
ret = rgw_mkdir(fs, dir.parent_fh, dir.name.c_str(), &st, create_mask,
&dir.fh, RGW_MKDIR_FLAG_NONE);
} else {
ret = rgw_lookup(fs, dir.parent_fh, dir.name.c_str(), &dir.fh,
nullptr, 0, RGW_LOOKUP_FLAG_NONE);
}
ASSERT_EQ(ret, 0);
dir.sync();
ovec.push_back(dir);
if (verbose) {
std::cout << "create: " << dir.name << std::endl;
}
}
}
TEST(LibRGW, CHECK_PATH_REFS) {
if (!bucket_fh)
return;
int ix, sz = ovec.size();
for (ix = 0; ix < sz; ++ix) {
auto& dir = ovec[ix];
if (verbose) {
std::cout << "name: " << dir.name
<< " refcnt: " << dir.rgw_fh->get_refcnt()
<< std::endl;
}
if (ix == 0) {
// sentinel, +1 parent, +1 path
ASSERT_EQ(dir.rgw_fh->get_refcnt(), 3U);
}
if (ix == 1) {
// sentinel, +1 path
ASSERT_EQ(dir.rgw_fh->get_refcnt(), 2U);
}
}
}
TEST(LibRGW, SETXATTR1) {
if (!bucket_fh)
return;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr xattr_k = { const_cast<char*>(key1.c_str()),
uint32_t(key1.length()) };
rgw_xattrstr xattr_v = { const_cast<char*>(val1.c_str()),
uint32_t(val1.length()) };
rgw_xattr xattr = { xattr_k, xattr_v };
rgw_xattrlist xattrlist = { &xattr, 1 };
int ret = rgw_setxattrs(fs, dir.fh, &xattrlist, RGW_SETXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
extern "C" {
static int getattr_cb(rgw_xattrlist *attrs, void *arg, uint32_t flags)
{
auto& attrmap =
*(static_cast<std::map<std::string, std::string>*>(arg));
for (uint32_t ix = 0; ix < attrs->xattr_cnt; ++ix) {
auto& xattr = attrs->xattrs[ix];
string k{xattr.key.val, xattr.key.len};
string v{xattr.val.val, xattr.val.len};
if (verbose) {
std::cout << __func__
<< " attr k: " << k << " v: " << v
<< std::endl;
}
attrmap.insert(std::map<std::string, std::string>::value_type(k, v));
}
return 0;
}
}
TEST(LibRGW, GETXATTR1) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr xattr_k1 =
{const_cast<char*>(key1.c_str()), uint32_t(key1.length())};
rgw_xattrstr xattr_v1 = {nullptr, 0};
std::string key2 = "user.rgw.etag";
rgw_xattrstr xattr_k2 =
{const_cast<char*>(key2.c_str()), uint32_t(key2.length())};
rgw_xattrstr xattr_v2 = {nullptr, 0};
rgw_xattr xattrs[2] = {{xattr_k1, xattr_v1},
{xattr_k2, xattr_v2}};
/* XXX gcc won't accept static_cast here, don't see why */
rgw_xattrlist xattrlist = {reinterpret_cast<rgw_xattr*>(&xattrs), 2};
std::map<std::string, std::string> out_attrmap;
int ret = rgw_getxattrs(fs, dir.fh, &xattrlist, getattr_cb, &out_attrmap,
RGW_GETXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
/* check exposed attrs */
ASSERT_TRUE(out_attrmap.find("user.rgw.etag") != out_attrmap.end());
/* check our user attr */
ASSERT_TRUE(out_attrmap.find(key1) != out_attrmap.end());
}
TEST(LibRGW, LSXATTR1) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr filter_prefix = { nullptr, 0}; // XXX ignored, for now
std::map<std::string, std::string> out_attrmap;
int ret = rgw_lsxattrs(fs, dir.fh, &filter_prefix, getattr_cb,
&out_attrmap, RGW_LSXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
/* check exposed attrs */
ASSERT_TRUE(out_attrmap.find("user.rgw.etag") != out_attrmap.end());
}
TEST(LibRGW, RMXATTR1) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr xattr_k = { const_cast<char*>(key1.c_str()),
uint32_t(key1.length()) };
rgw_xattrstr xattr_v = { nullptr, 0 };
rgw_xattr xattr = { xattr_k, xattr_v };
rgw_xattrlist xattrlist = { &xattr, 1 };
int ret = rgw_rmxattrs(fs, dir.fh, &xattrlist, RGW_RMXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, LSXATTR2) {
if (!bucket_fh)
return;
using std::get;
auto& dir = ovec[ovec.size()-1];
rgw_xattrstr filter_prefix = { nullptr, 0 }; // XXX ignored, for now
std::map<std::string, std::string> out_attrmap;
int ret = rgw_lsxattrs(fs, dir.fh, &filter_prefix, getattr_cb,
&out_attrmap, RGW_LSXATTR_FLAG_NONE);
ASSERT_EQ(ret, 0);
/* check exposed attrs */
ASSERT_TRUE(out_attrmap.find("user.rgw.etag") != out_attrmap.end());
/* verify deletion */
ASSERT_TRUE(out_attrmap.find(key1) == out_attrmap.end());
}
TEST(LibRGW, CLEANUP) {
int ret = 0;
if (object_fh) {
ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
ASSERT_EQ(ret, 0);
}
if (bucket_fh) {
ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
}
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, UMOUNT) {
if (! fs)
return;
int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
ASSERT_EQ(ret, 0);
}
TEST(LibRGW, SHUTDOWN) {
librgw_shutdown(rgw_h);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
env_to_vec(args);
char* v = getenv("AWS_ACCESS_KEY_ID");
if (v) {
access_key = v;
}
v = getenv("AWS_SECRET_ACCESS_KEY");
if (v) {
secret_key = v;
}
string val;
for (auto arg_iter = args.begin(); arg_iter != args.end();) {
if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
(char*) nullptr)) {
access_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
(char*) nullptr)) {
secret_key = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
(char*) nullptr)) {
uid = val;
} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
(char*) nullptr)) {
bucket_name = val;
} else if (ceph_argparse_flag(args, arg_iter, "--stat",
(char*) nullptr)) {
do_stat = true;
} else if (ceph_argparse_flag(args, arg_iter, "--create",
(char*) nullptr)) {
do_create = true;
} else if (ceph_argparse_flag(args, arg_iter, "--delete",
(char*) nullptr)) {
do_delete = true;
} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
(char*) nullptr)) {
do_hexdump = true;
} else if (ceph_argparse_flag(args, arg_iter, "--verbose",
(char*) nullptr)) {
verbose = true;
} else {
++arg_iter;
}
}
/* dont accidentally run as anonymous */
if ((access_key == "") ||
(secret_key == "")) {
std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
return EPERM;
}
saved_args.argc = argc;
saved_args.argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 10,598 | 23.421659 | 79 |
cc
|
null |
ceph-main/src/test/mime.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/mime.h"
#include "gtest/gtest.h"
#include <stdint.h>
#include <string>
using std::string;
TEST(MimeTests, SimpleEncode) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_encode_as_qp("abc", NULL, 0);
ASSERT_EQ(len, 4);
len = mime_encode_as_qp("abc", output, 4);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("abc"), string(output));
len = mime_encode_as_qp("a=b", NULL, 0);
ASSERT_EQ(len, 6);
len = mime_encode_as_qp("a=b", output, 6);
ASSERT_EQ(len, 6);
ASSERT_EQ(string("a=3Db"), string(output));
len = mime_encode_as_qp("Libert\xc3\xa9", NULL, 0);
ASSERT_EQ(len, 13);
len = mime_encode_as_qp("Libert\xc3\xa9", output, 13);
ASSERT_EQ(len, 13);
ASSERT_EQ(string("Libert=C3=A9"), string(output));
}
TEST(MimeTests, EncodeOutOfSpace) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_encode_as_qp("abcdefg", NULL, 0);
ASSERT_EQ(len, 8);
len = mime_encode_as_qp("abcdefg", output, 4);
ASSERT_EQ(len, 8);
ASSERT_EQ(string("abc"), string(output));
len = mime_encode_as_qp("abcdefg", output, 1);
ASSERT_EQ(len, 8);
ASSERT_EQ(string(""), string(output));
len = mime_encode_as_qp("a=b", output, 2);
ASSERT_EQ(len, 6);
ASSERT_EQ(string("a"), string(output));
len = mime_encode_as_qp("a=b", output, 3);
ASSERT_EQ(len, 6);
ASSERT_EQ(string("a"), string(output));
}
TEST(MimeTests, SimpleDecode) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_decode_from_qp("abc", NULL, 0);
ASSERT_EQ(len, 4);
len = mime_decode_from_qp("abc", output, 4);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("abc"), string(output));
len = mime_decode_from_qp("a=3Db", NULL, 0);
ASSERT_EQ(len, 4);
len = mime_decode_from_qp("a=3Db", output, 4);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("a=b"), string(output));
len = mime_decode_from_qp("Libert=C3=A9", NULL, 0);
ASSERT_EQ(len, 9);
len = mime_decode_from_qp("Libert=C3=A9", output, 9);
ASSERT_EQ(len, 9);
ASSERT_EQ(string("Libert\xc3\xa9"), string(output));
}
TEST(MimeTests, LowercaseDecode) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_decode_from_qp("Libert=c3=a9", NULL, 0);
ASSERT_EQ(len, 9);
len = mime_decode_from_qp("Libert=c3=a9", output, 9);
ASSERT_EQ(len, 9);
ASSERT_EQ(string("Libert\xc3\xa9"), string(output));
}
TEST(MimeTests, DecodeOutOfSpace) {
char output[256];
memset(output, 0, sizeof(output));
int len;
len = mime_decode_from_qp("abcdefg", NULL, 0);
ASSERT_EQ(len, 8);
len = mime_decode_from_qp("abcdefg", output, 4);
ASSERT_EQ(len, 8);
ASSERT_EQ(string("abc"), string(output));
len = mime_decode_from_qp("abcdefg", output, 1);
ASSERT_EQ(len, 8);
ASSERT_EQ(string(""), string(output));
len = mime_decode_from_qp("a=3Db", output, 2);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("a"), string(output));
len = mime_decode_from_qp("a=3Db", output, 3);
ASSERT_EQ(len, 4);
ASSERT_EQ(string("a="), string(output));
}
TEST(MimeTests, DecodeErrors) {
char output[128];
memset(output, 0, sizeof(output));
int len;
// incomplete escape sequence
len = mime_decode_from_qp("boo=", output, sizeof(output));
ASSERT_LT(len, 0);
// invalid escape sequences
len = mime_decode_from_qp("boo=gg", output, sizeof(output));
ASSERT_LT(len, 0);
len = mime_decode_from_qp("boo=g", output, sizeof(output));
ASSERT_LT(len, 0);
len = mime_decode_from_qp("boo==", output, sizeof(output));
ASSERT_LT(len, 0);
len = mime_decode_from_qp("boo=44bar=z", output, sizeof(output));
ASSERT_LT(len, 0);
// high bit should not be set in quoted-printable mime output
unsigned char bad_input2[] = { 0x81, 0x6a, 0x0 };
len = mime_decode_from_qp(reinterpret_cast<const char*>(bad_input2),
output, sizeof(output));
ASSERT_LT(len, 0);
}
| 4,248 | 27.139073 | 70 |
cc
|
null |
ceph-main/src/test/multi_stress_watch.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
#include "include/rados/librados.h"
#include "include/rados/librados.hpp"
#include "test/librados/test_cxx.h"
#include <errno.h>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <map>
#include <iostream>
#include <string>
#include <stdlib.h>
#include <unistd.h>
using namespace librados;
using std::map;
using std::string;
class WatchNotifyTestCtx : public WatchCtx
{
public:
WatchNotifyTestCtx(std::mutex &lock)
: lock{lock} {}
void notify(uint8_t opcode, uint64_t ver, bufferlist &bl) override {
std::unique_lock locker {lock};
notified = true;
cond.notify_one();
}
bool wait() {
std::unique_lock locker {lock};
return cond.wait_for(locker, std::chrono::seconds(1200),
[this] { return notified; });
}
private:
bool notified = false;
std::mutex& lock;
std::condition_variable cond;
};
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
void
test_loop(Rados &cluster, std::string pool_name, std::string obj_name)
{
int ret;
IoCtx ioctx;
ret = cluster.ioctx_create(pool_name.c_str(), ioctx);
if (ret < 0) {
std::cerr << "ioctx_create " << pool_name << " failed with " << ret << std::endl;
exit(1);
}
ioctx.application_enable("rados", true);
ret = ioctx.create(obj_name, false);
if (ret < 0) {
std::cerr << "create failed with " << ret << std::endl;
exit(1);
}
std::mutex lock;
constexpr int NR_ITERATIONS = 10000;
for (int i = 0; i < NR_ITERATIONS; ++i) {
std::cout << "Iteration " << i << std::endl;
uint64_t handle;
WatchNotifyTestCtx ctx{lock};
ret = ioctx.watch(obj_name, 0, &handle, &ctx);
ceph_assert(!ret);
bufferlist bl2;
ret = ioctx.notify(obj_name, 0, bl2);
ceph_assert(!ret);
ceph_assert_always(ctx.wait());
ioctx.unwatch(obj_name, handle);
}
ioctx.close();
ret = cluster.pool_delete(pool_name.c_str());
if (ret < 0) {
std::cerr << "pool_delete failed with " << ret << std::endl;
exit(1);
}
}
#pragma GCC diagnostic pop
#pragma GCC diagnostic warning "-Wpragmas"
void
test_replicated(Rados &cluster, std::string pool_name, const std::string &obj_name)
{
// May already exist
cluster.pool_create(pool_name.c_str());
test_loop(cluster, pool_name, obj_name);
}
void
test_erasure(Rados &cluster, const std::string &pool_name, const std::string &obj_name)
{
string outs;
bufferlist inbl;
int ret;
ret = cluster.mon_command(
"{\"prefix\": \"osd erasure-code-profile set\", \"name\": \"testprofile\", \"profile\": [ \"k=2\", \"m=1\", \"crush-failure-domain=osd\"]}",
inbl, NULL, &outs);
if (ret < 0) {
std::cerr << "mon_command erasure-code-profile set failed with " << ret << std::endl;
exit(1);
}
//std::cout << outs << std::endl;
outs.clear();
ret = cluster.mon_command(
"{\"prefix\": \"osd pool create\", \"pool\": \"" + pool_name + "\", \"pool_type\":\"erasure\", \"pg_num\":12, \"pgp_num\":12, \"erasure_code_profile\":\"testprofile\"}",
inbl, NULL, &outs);
if (ret < 0) {
std::cerr << outs << std::endl;
std::cerr << "mon_command create pool failed with " << ret << std::endl;
exit(1);
}
//std::cout << outs << std::endl;
cluster.wait_for_latest_osdmap();
test_loop(cluster, pool_name, obj_name);
return;
}
int main(int args, char **argv)
{
if (args != 3 && args != 4) {
std::cerr << "Error: " << argv[0] << " [ec|rep] pool_name obj_name" << std::endl;
return 1;
}
std::string pool_name, obj_name, type;
// For backward compatibility with unmodified teuthology version
if (args == 3) {
type = "rep";
pool_name = argv[1];
obj_name = argv[2];
} else {
type = argv[1];
pool_name = argv[2];
obj_name = argv[3];
}
std::cout << "Test type " << type << std::endl;
std::cout << "pool_name, obj_name are " << pool_name << ", " << obj_name << std::endl;
if (type != "ec" && type != "rep") {
std::cerr << "Error: " << argv[0] << " Invalid arg must be 'ec' or 'rep' saw " << type << std::endl;
return 1;
}
Rados cluster;
std::string err = connect_cluster_pp(cluster);
if (err.length()) {
std::cerr << "Error " << err << std::endl;
return 1;
}
if (type == "rep")
test_replicated(cluster, pool_name, obj_name);
else if (type == "ec")
test_erasure(cluster, pool_name, obj_name);
return 0;
}
| 4,493 | 25.435294 | 173 |
cc
|
null |
ceph-main/src/test/objectstore_bench.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <chrono>
#include <cassert>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <thread>
#include "os/ObjectStore.h"
#include "global/global_init.h"
#include "common/strtol.h"
#include "common/ceph_argparse.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_filestore
using namespace std;
static void usage()
{
cout << "usage: ceph_objectstore_bench [flags]\n"
" --size\n"
" total size in bytes\n"
" --block-size\n"
" block size in bytes for each write\n"
" --repeats\n"
" number of times to repeat the write cycle\n"
" --threads\n"
" number of threads to carry out this workload\n"
" --multi-object\n"
" have each thread write to a separate object\n" << std::endl;
generic_server_usage();
}
// helper class for bytes with units
struct byte_units {
size_t v;
// cppcheck-suppress noExplicitConstructor
byte_units(size_t v) : v(v) {}
bool parse(const std::string &val, std::string *err);
operator size_t() const { return v; }
};
bool byte_units::parse(const std::string &val, std::string *err)
{
v = strict_iecstrtoll(val, err);
return err->empty();
}
std::ostream& operator<<(std::ostream &out, const byte_units &amount)
{
static const char* units[] = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
static const int max_units = sizeof(units)/sizeof(*units);
int unit = 0;
auto v = amount.v;
while (v >= 1024 && unit < max_units) {
// preserve significant bytes
if (v < 1048576 && (v % 1024 != 0))
break;
v >>= 10;
unit++;
}
return out << v << ' ' << units[unit];
}
struct Config {
byte_units size;
byte_units block_size;
int repeats;
int threads;
bool multi_object;
Config()
: size(1048576), block_size(4096),
repeats(1), threads(1),
multi_object(false) {}
};
class C_NotifyCond : public Context {
std::mutex *mutex;
std::condition_variable *cond;
bool *done;
public:
C_NotifyCond(std::mutex *mutex, std::condition_variable *cond, bool *done)
: mutex(mutex), cond(cond), done(done) {}
void finish(int r) override {
std::lock_guard<std::mutex> lock(*mutex);
*done = true;
cond->notify_one();
}
};
void osbench_worker(ObjectStore *os, const Config &cfg,
const coll_t cid, const ghobject_t oid,
uint64_t starting_offset)
{
bufferlist data;
data.append(buffer::create(cfg.block_size));
dout(0) << "Writing " << cfg.size
<< " in blocks of " << cfg.block_size << dendl;
ceph_assert(starting_offset < cfg.size);
ceph_assert(starting_offset % cfg.block_size == 0);
ObjectStore::CollectionHandle ch = os->open_collection(cid);
ceph_assert(ch);
for (int i = 0; i < cfg.repeats; ++i) {
uint64_t offset = starting_offset;
size_t len = cfg.size;
vector<ObjectStore::Transaction> tls;
std::cout << "Write cycle " << i << std::endl;
while (len) {
size_t count = len < cfg.block_size ? len : (size_t)cfg.block_size;
auto t = new ObjectStore::Transaction;
t->write(cid, oid, offset, count, data);
tls.push_back(std::move(*t));
delete t;
offset += count;
if (offset > cfg.size)
offset -= cfg.size;
len -= count;
}
// set up the finisher
std::mutex mutex;
std::condition_variable cond;
bool done = false;
tls.back().register_on_commit(new C_NotifyCond(&mutex, &cond, &done));
os->queue_transactions(ch, tls);
std::unique_lock<std::mutex> lock(mutex);
cond.wait(lock, [&done](){ return done; });
lock.unlock();
}
}
int main(int argc, const char *argv[])
{
// command-line arguments
auto args = argv_to_vec(argc, argv);
if (args.empty()) {
cerr << argv[0] << ": -h or --help for usage" << std::endl;
exit(1);
}
if (ceph_argparse_need_usage(args)) {
usage();
exit(0);
}
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
Config cfg;
std::string val;
vector<const char*>::iterator i = args.begin();
while (i != args.end()) {
if (ceph_argparse_double_dash(args, i))
break;
if (ceph_argparse_witharg(args, i, &val, "--size", (char*)nullptr)) {
std::string err;
if (!cfg.size.parse(val, &err)) {
derr << "error parsing size: " << err << dendl;
exit(1);
}
} else if (ceph_argparse_witharg(args, i, &val, "--block-size", (char*)nullptr)) {
std::string err;
if (!cfg.block_size.parse(val, &err)) {
derr << "error parsing block-size: " << err << dendl;
exit(1);
}
} else if (ceph_argparse_witharg(args, i, &val, "--repeats", (char*)nullptr)) {
cfg.repeats = atoi(val.c_str());
} else if (ceph_argparse_witharg(args, i, &val, "--threads", (char*)nullptr)) {
cfg.threads = atoi(val.c_str());
} else if (ceph_argparse_flag(args, i, "--multi-object", (char*)nullptr)) {
cfg.multi_object = true;
} else {
derr << "Error: can't understand argument: " << *i << "\n" << dendl;
exit(1);
}
}
common_init_finish(g_ceph_context);
// create object store
dout(0) << "objectstore " << g_conf()->osd_objectstore << dendl;
dout(0) << "data " << g_conf()->osd_data << dendl;
dout(0) << "journal " << g_conf()->osd_journal << dendl;
dout(0) << "size " << cfg.size << dendl;
dout(0) << "block-size " << cfg.block_size << dendl;
dout(0) << "repeats " << cfg.repeats << dendl;
dout(0) << "threads " << cfg.threads << dendl;
auto os =
ObjectStore::create(g_ceph_context,
g_conf()->osd_objectstore,
g_conf()->osd_data,
g_conf()->osd_journal);
//Checking data folder: create if needed or error if it's not empty
DIR *dir = ::opendir(g_conf()->osd_data.c_str());
if (!dir) {
std::string cmd("mkdir -p ");
cmd+=g_conf()->osd_data;
int r = ::system( cmd.c_str() );
if( r<0 ){
derr << "Failed to create data directory, ret = " << r << dendl;
return 1;
}
}
else {
bool non_empty = readdir(dir) != NULL && readdir(dir) != NULL && readdir(dir) != NULL;
if( non_empty ){
derr << "Data directory '"<<g_conf()->osd_data<<"' isn't empty, please clean it first."<< dendl;
return 1;
}
}
::closedir(dir);
//Create folders for journal if needed
string journal_base = g_conf()->osd_journal.substr(0, g_conf()->osd_journal.rfind('/'));
struct stat sb;
if (stat(journal_base.c_str(), &sb) != 0 ){
std::string cmd("mkdir -p ");
cmd+=journal_base;
int r = ::system( cmd.c_str() );
if( r<0 ){
derr << "Failed to create journal directory, ret = " << r << dendl;
return 1;
}
}
if (!os) {
derr << "bad objectstore type " << g_conf()->osd_objectstore << dendl;
return 1;
}
if (os->mkfs() < 0) {
derr << "mkfs failed" << dendl;
return 1;
}
if (os->mount() < 0) {
derr << "mount failed" << dendl;
return 1;
}
dout(10) << "created objectstore " << os.get() << dendl;
// create a collection
spg_t pg;
const coll_t cid(pg);
ObjectStore::CollectionHandle ch = os->create_new_collection(cid);
{
ObjectStore::Transaction t;
t.create_collection(cid, 0);
os->queue_transaction(ch, std::move(t));
}
// create the objects
std::vector<ghobject_t> oids;
if (cfg.multi_object) {
oids.reserve(cfg.threads);
for (int i = 0; i < cfg.threads; i++) {
std::stringstream oss;
oss << "osbench-thread-" << i;
oids.emplace_back(hobject_t(sobject_t(oss.str(), CEPH_NOSNAP)));
ObjectStore::Transaction t;
t.touch(cid, oids[i]);
int r = os->queue_transaction(ch, std::move(t));
ceph_assert(r == 0);
}
} else {
oids.emplace_back(hobject_t(sobject_t("osbench", CEPH_NOSNAP)));
ObjectStore::Transaction t;
t.touch(cid, oids.back());
int r = os->queue_transaction(ch, std::move(t));
ceph_assert(r == 0);
}
// run the worker threads
std::vector<std::thread> workers;
workers.reserve(cfg.threads);
using namespace std::chrono;
auto t1 = high_resolution_clock::now();
for (int i = 0; i < cfg.threads; i++) {
const auto &oid = cfg.multi_object ? oids[i] : oids[0];
workers.emplace_back(osbench_worker, os.get(), std::ref(cfg),
cid, oid, i * cfg.size / cfg.threads);
}
for (auto &worker : workers)
worker.join();
auto t2 = high_resolution_clock::now();
workers.clear();
auto duration = duration_cast<microseconds>(t2 - t1);
byte_units total = cfg.size * cfg.repeats * cfg.threads;
byte_units rate = (1000000LL * total) / duration.count();
size_t iops = (1000000LL * total / cfg.block_size) / duration.count();
dout(0) << "Wrote " << total << " in "
<< duration.count() << "us, at a rate of " << rate << "/s and "
<< iops << " iops" << dendl;
// remove the objects
ObjectStore::Transaction t;
for (const auto &oid : oids)
t.remove(cid, oid);
os->queue_transaction(ch, std::move(t));
os->umount();
return 0;
}
| 9,291 | 27.157576 | 103 |
cc
|
null |
ceph-main/src/test/omap_bench.cc
|
/*
* Generate latency statistics for a configurable number of write
* operations of configurable size.
*
* Created on: May 21, 2012
* Author: Eleanor Cawthon
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#include "include/rados/librados.hpp"
#include "include/Context.h"
#include "common/ceph_context.h"
#include "common/ceph_mutex.h"
#include "common/Cond.h"
#include "include/utime.h"
#include "common/ceph_argparse.h"
#include "test/omap_bench.h"
#include <string>
#include <iostream>
#include <cassert>
#include <climits>
#include <cmath>
using namespace std;
using ceph::bufferlist;
int OmapBench::setup(int argc, const char** argv) {
//parse key_value_store_bench args
auto args = argv_to_vec(argc, argv);
for (unsigned i = 0; i < args.size(); i++) {
if(i < args.size() - 1) {
if (strcmp(args[i], "-t") == 0) {
threads = atoi(args[i+1]);
} else if (strcmp(args[i], "-o") == 0) {
objects = atoi(args[i+1]);
} else if (strcmp(args[i], "--entries") == 0) {
entries_per_omap = atoi(args[i+1]);
} else if (strcmp(args[i], "--keysize") == 0) {
key_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--valsize") == 0) {
value_size = atoi(args[i+1]);
} else if (strcmp(args[i], "--inc") == 0) {
increment = atoi(args[i+1]);
} else if (strcmp(args[i], "--omaptype") == 0) {
if(strcmp("rand",args[i+1]) == 0) {
omap_generator = OmapBench::generate_non_uniform_omap;
}
else if (strcmp("uniform", args[i+1]) == 0) {
omap_generator = OmapBench::generate_uniform_omap;
}
} else if (strcmp(args[i], "--name") == 0) {
rados_id = args[i+1];
}
} else if (strcmp(args[i], "--help") == 0) {
cout << "\nUsage: ostorebench [options]\n"
<< "Generate latency statistics for a configurable number of "
<< "key value pair operations of\n"
<< "configurable size.\n\n"
<< "OPTIONS\n"
<< " -t number of threads to use (default "<<threads;
cout << ")\n"
<< " -o number of objects to write (default "<<objects;
cout << ")\n"
<< " --entries number of entries per (default "
<< entries_per_omap;
cout <<")\n"
<< " --keysize number of characters per key "
<< "(default "<<key_size;
cout << ")\n"
<< " --valsize number of characters per value "
<< "(default "<<value_size;
cout << ")\n"
<< " --inc specify the increment to use in the displayed "
<< "histogram (default "<<increment;
cout << ")\n"
<< " --omaptype specify how omaps should be generated - "
<< "rand for random sizes between\n"
<< " 0 and max size, uniform for all sizes"
<< " to be specified size.\n"
<< " (default uniform)\n";
cout << " --name the rados id to use (default "<< rados_id
<< ")\n";
exit(1);
}
}
int r = rados.init(rados_id.c_str());
if (r < 0) {
cout << "error during init" << std::endl;
return r;
}
r = rados.conf_parse_argv(argc, argv);
if (r < 0) {
cout << "error during parsing args" << std::endl;
return r;
}
r = rados.conf_parse_env(NULL);
if (r < 0) {
cout << "error during parsing env" << std::endl;
return r;
}
r = rados.conf_read_file(NULL);
if (r < 0) {
cout << "error during read file" << std::endl;
return r;
}
r = rados.connect();
if (r < 0) {
cout << "error during connect" << std::endl;
return r;
}
r = rados.ioctx_create(pool_name.c_str(), io_ctx);
if (r < 0) {
cout << "error creating io ctx" << std::endl;
rados.shutdown();
return r;
}
return 0;
}
//Writer functions
Writer::Writer(OmapBench *omap_bench) : ob(omap_bench) {
stringstream name;
ob->data_lock.lock();
name << omap_bench->prefix << ++(ob->data.started_ops);
ob->data_lock.unlock();
oid = name.str();
}
void Writer::start_time() {
begin_time = ceph_clock_now();
}
void Writer::stop_time() {
end_time = ceph_clock_now();
}
double Writer::get_time() {
return (end_time - begin_time) * 1000;
}
string Writer::get_oid() {
return oid;
}
std::map<std::string, bufferlist> & Writer::get_omap() {
return omap;
}
//AioWriter functions
AioWriter::AioWriter(OmapBench *ob) : Writer(ob) {
aioc = NULL;
}
AioWriter::~AioWriter() {
if(aioc) aioc->release();
}
librados::AioCompletion * AioWriter::get_aioc() {
return aioc;
}
void AioWriter::set_aioc(librados::callback_t complete) {
aioc = ob->rados.aio_create_completion(this, complete);
}
//Helper methods
void OmapBench::aio_is_complete(rados_completion_t c, void *arg) {
AioWriter *aiow = reinterpret_cast<AioWriter *>(arg);
aiow->stop_time();
ceph::mutex * data_lock = &aiow->ob->data_lock;
ceph::mutex * thread_is_free_lock = &aiow->ob->thread_is_free_lock;
ceph::condition_variable* thread_is_free = &aiow->ob->thread_is_free;
int &busythreads_count = aiow->ob->busythreads_count;
o_bench_data &data = aiow->ob->data;
int INCREMENT = aiow->ob->increment;
int err = aiow->get_aioc()->get_return_value();
if (err < 0) {
cout << "error writing AioCompletion";
return;
}
double time = aiow->get_time();
delete aiow;
data_lock->lock();
data.avg_latency = (data.avg_latency * data.completed_ops + time)
/ (data.completed_ops + 1);
data.completed_ops++;
if (time < data.min_latency) {
data.min_latency = time;
}
if (time > data.max_latency) {
data.max_latency = time;
}
data.total_latency += time;
++(data.freq_map[time / INCREMENT]);
if(data.freq_map[time/INCREMENT] > data.mode.second) {
data.mode.first = time/INCREMENT;
data.mode.second = data.freq_map[time/INCREMENT];
}
data_lock->unlock();
thread_is_free_lock->lock();
busythreads_count--;
thread_is_free->notify_all();
thread_is_free_lock->unlock();
}
string OmapBench::random_string(int len) {
string ret;
string alphanum = "0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < len; ++i) {
ret.push_back(alphanum[rand() % (alphanum.size() - 1)]);
}
return ret;
}
int OmapBench::run() {
return (((OmapBench *)this)->*OmapBench::test)(omap_generator);
}
int OmapBench::print_written_omap() {
for (int i = 1; i <= objects; i++) {
int err = 0;
librados::ObjectReadOperation key_read;
set<string> out_keys;
map<string, bufferlist> out_vals;
std::stringstream objstrm;
objstrm << prefix;
objstrm << i;
cout << "\nPrinting omap for "<<objstrm.str() << std::endl;
// FIXME: we ignore pmore here. this shouldn't happen for benchmark
// keys, though, unless the OSD limit is *really* low.
key_read.omap_get_keys2("", LONG_MAX, &out_keys, nullptr, &err);
io_ctx.operate(objstrm.str(), &key_read, NULL);
if (err < 0) {
cout << "error " << err;
cout << " getting omap key set " << std::endl;
return err;
}
librados::ObjectReadOperation val_read;
val_read.omap_get_vals_by_keys(out_keys, &out_vals, &err);
if (err < 0) {
cout << "error " << err;
cout << " getting omap value set " << std::endl;
return err;
}
io_ctx.operate(objstrm.str(), &val_read, NULL);
for (set<string>::iterator iter = out_keys.begin();
iter != out_keys.end(); ++iter) {
cout << *iter << "\t" << (out_vals)[*iter] << std::endl;
}
}
return 0;
}
void OmapBench::print_results() {
cout << "========================================================";
cout << "\nNumber of kvmaps written:\t" << objects;
cout << "\nNumber of ops at once:\t" << threads;
cout << "\nEntries per kvmap:\t\t" << entries_per_omap;
cout << "\nCharacters per key:\t" << key_size;
cout << "\nCharacters per val:\t" << value_size;
cout << std::endl;
cout << std::endl;
cout << "Average latency:\t" << data.avg_latency;
cout << "ms\nMinimum latency:\t" << data.min_latency;
cout << "ms\nMaximum latency:\t" << data.max_latency;
cout << "ms\nMode latency:\t\t"<<"between "<<data.mode.first * increment;
cout << " and " <<data.mode.first * increment + increment;
cout << "ms\nTotal latency:\t\t" << data.total_latency;
cout << "ms"<<std::endl;
cout << std::endl;
cout << "Histogram:" << std::endl;
for(int i = floor(data.min_latency / increment); i <
ceil(data.max_latency / increment); i++) {
cout << ">= "<< i * increment;
cout << "ms";
int spaces;
if (i == 0) spaces = 4;
else spaces = 3 - floor(log10(i));
for (int j = 0; j < spaces; j++) {
cout << " ";
}
cout << "[";
for(int j = 0; j < ((data.freq_map)[i])*45/(data.mode.second); j++) {
cout << "*";
}
cout << std::endl;
}
cout << "\n========================================================"
<< std::endl;
}
int OmapBench::write_omap_asynchronously(AioWriter *aiow,
const std::map<std::string,bufferlist> &omap) {
librados::ObjectWriteOperation owo;
owo.create(false);
owo.omap_clear();
owo.omap_set(omap);
aiow->start_time();
int err = io_ctx.aio_operate(aiow->get_oid(), aiow->get_aioc(), &owo);
if (err < 0) {
cout << "writing omap failed with code "<<err;
cout << std::endl;
return err;
}
return 0;
}
//Omap Generators
int OmapBench::generate_uniform_omap(const int omap_entries, const int key_size,
const int value_size, std::map<std::string,bufferlist> * out_omap) {
bufferlist bl;
//setup omap
for (int i = 0; i < omap_entries; i++) {
bufferlist omap_val;
omap_val.append(random_string(value_size));
string key = random_string(key_size);
(*out_omap)[key]= omap_val;
}
return 0;
}
int OmapBench::generate_non_uniform_omap(const int omap_entries,
const int key_size, const int value_size,
std::map<std::string,bufferlist> * out_omap) {
bufferlist bl;
int num_entries = rand() % omap_entries + 1;
int key_len = rand() % key_size +1;
int val_len = rand() % value_size +1;
//setup omap
for (int i = 0; i < num_entries; i++) {
bufferlist omap_val;
omap_val.append(random_string(val_len));
string key = random_string(key_len);
(*out_omap)[key] = omap_val;
}
return 0;
}
int OmapBench::generate_small_non_random_omap(const int omap_entries,
const int key_size, const int value_size,
std::map<std::string,bufferlist> * out_omap) {
bufferlist bl;
stringstream key;
//setup omap
for (int i = 0; i < omap_entries; i++) {
bufferlist omap_val;
omap_val.append("Value ");
omap_val.append(i);
key << "Key " << i;
(*out_omap)[key.str()]= omap_val;
}
return 0;
}
//tests
int OmapBench::test_write_objects_in_parallel(omap_generator_t omap_gen) {
AioWriter *this_aio_writer;
std::unique_lock l{thread_is_free_lock};
for (int i = 0; i < objects; i++) {
ceph_assert(busythreads_count <= threads);
//wait for a writer to be free
if (busythreads_count == threads) {
thread_is_free.wait(l);
ceph_assert(busythreads_count < threads);
}
//set up the write
this_aio_writer = new AioWriter(this);
this_aio_writer->set_aioc(comp);
//perform the write
busythreads_count++;
int err = omap_gen(entries_per_omap, key_size, value_size,
& this_aio_writer->get_omap());
if (err < 0) {
return err;
}
err = OmapBench::write_omap_asynchronously(this_aio_writer,
(this_aio_writer->get_omap()));
if (err < 0) {
return err;
}
}
thread_is_free.wait(l, [this] { return busythreads_count <= 0;});
return 0;
}
/**
* runs the specified test with the specified parameters and generates
* a histogram of latencies
*/
int main(int argc, const char** argv) {
OmapBench ob;
int err = ob.setup(argc, argv);
if (err<0) {
cout << "error during setup: "<<err;
cout << std::endl;
exit(1);
}
err = ob.run();
if (err < 0) {
cout << "writing objects failed with code " << err;
cout << std::endl;
return err;
}
ob.print_results();
//uncomment to show omaps
/*err = ob.return print_written_omap();
if (err < 0) {
cout << "printing omaps failed with code " << err;
cout << std::endl;
return err;
}
*/
return 0;
}
| 12,407 | 27.722222 | 80 |
cc
|
null |
ceph-main/src/test/omap_bench.h
|
/*
* Generate latency statistics for a configurable number of object map write
* operations of configurable size.
*
* Created on: May 21, 2012
* Author: Eleanor Cawthon
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*/
#ifndef OMAP_BENCH_HPP_
#define OMAP_BENCH_HPP_
#include "common/ceph_mutex.h"
#include "common/Cond.h"
#include "include/rados/librados.hpp"
#include <string>
#include <map>
#include <cfloat>
using ceph::bufferlist;
struct o_bench_data {
double avg_latency;
double min_latency;
double max_latency;
double total_latency;
int started_ops;
int completed_ops;
std::map<int,int> freq_map;
std::pair<int,int> mode;
o_bench_data()
: avg_latency(0.0), min_latency(DBL_MAX), max_latency(0.0),
total_latency(0.0),
started_ops(0), completed_ops(0)
{}
};
class OmapBench;
typedef int (*omap_generator_t)(const int omap_entries, const int key_size,
const int value_size,
std::map<std::string,bufferlist> *out_omap);
typedef int (OmapBench::*test_t)(omap_generator_t omap_gen);
class Writer{
protected:
std::string oid;
utime_t begin_time;
utime_t end_time;
std::map<std::string,bufferlist> omap;
OmapBench *ob;
friend class OmapBench;
public:
Writer(OmapBench *omap_bench);
virtual ~Writer(){};
virtual void start_time();
virtual void stop_time();
virtual double get_time();
virtual std::string get_oid();
virtual std::map<std::string,bufferlist> & get_omap();
};
class AioWriter : public Writer{
protected:
librados::AioCompletion * aioc;
friend class OmapBench;
public:
AioWriter(OmapBench *omap_bench);
~AioWriter() override;
virtual librados::AioCompletion * get_aioc();
virtual void set_aioc(librados::callback_t complete);
};
class OmapBench{
protected:
librados::IoCtx io_ctx;
librados::Rados rados;
struct o_bench_data data;
test_t test;
omap_generator_t omap_generator;
//aio things
ceph::condition_variable thread_is_free;
ceph::mutex thread_is_free_lock =
ceph::make_mutex("OmapBench::thread_is_free_lock");
ceph::mutex data_lock =
ceph::make_mutex("OmapBench::data_lock");
int busythreads_count;
librados::callback_t comp;
std::string pool_name;
std::string rados_id;
std::string prefix;
int threads;
int objects;
int entries_per_omap;
int key_size;
int value_size;
double increment;
friend class Writer;
friend class AioWriter;
public:
OmapBench()
: test(&OmapBench::test_write_objects_in_parallel),
omap_generator(generate_uniform_omap),
busythreads_count(0),
comp(aio_is_complete),
pool_name("rbd"),
rados_id("admin"),
prefix(rados_id+".obj."),
threads(3), objects(100), entries_per_omap(10), key_size(10),
value_size(100), increment(10)
{}
/**
* Parses command line args, initializes rados and ioctx
*/
int setup(int argc, const char** argv);
/**
* Callback for when an AioCompletion (called from an AioWriter)
* is complete. deletes the AioWriter that called it,
* Updates data, updates busythreads, and signals thread_is_free.
*
* @param c provided by aio_write - not used
* @param arg the AioWriter that contains this AioCompletion
*/
static void aio_is_complete(rados_completion_t c, void *arg);
/**
* Generates a random string len characters long
*/
static std::string random_string(int len);
/*
* runs the test specified by test using the omap generator specified by
* omap_generator
*
* @return error code
*/
int run();
/*
* Prints all keys and values for all omap entries for all objects
*/
int print_written_omap();
/*
* Displays relevant constants and the histogram generated through a test
*/
void print_results();
/**
* Writes an object with the specified AioWriter.
*
* @param aiow the AioWriter to write with
* @param omap the omap to write
* @post: an asynchronous omap_set is launched
*/
int write_omap_asynchronously(AioWriter *aiow,
const std::map<std::string,bufferlist> &map);
/**
* Generates an omap with omap_entries entries, each with keys key_size
* characters long and with string values value_size characters long.
*
* @param out_map pointer to the map to be created
* @return error code
*/
static int generate_uniform_omap(const int omap_entries, const int key_size,
const int value_size, std::map<std::string,bufferlist> * out_omap);
/**
* The same as generate_uniform_omap except that string lengths are picked
* randomly between 1 and the int arguments
*/
static int generate_non_uniform_omap(const int omap_entries,
const int key_size,
const int value_size, std::map<std::string,bufferlist> * out_omap);
static int generate_small_non_random_omap(const int omap_entries,
const int key_size, const int value_size,
std::map<std::string,bufferlist> * out_omap);
/*
* Uses aio_write to write omaps generated by omap_gen to OBJECTS objects
* using THREADS AioWriters at a time.
*
* @param omap_gen the method used to generate the omaps.
*/
int test_write_objects_in_parallel(omap_generator_t omap_gen);
};
#endif /* OMAP_BENCH_HPP_ */
| 5,375 | 24.971014 | 78 |
h
|
null |
ceph-main/src/test/on_exit.cc
|
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
#include "include/on_exit.h"
#include "include/ceph_assert.h"
#ifndef MAP_ANONYMOUS
# ifdef MAP_ANON
# define MAP_ANONYMOUS MAP_ANON
# else
// cppcheck-suppress preprocessorErrorDirective
# error "Don't know how to create anonymous mmap"
# endif
#endif
static int func_scope_val;
static void add(void *incp)
{
func_scope_val += *((int*)incp);
}
static void func_scope(void)
{
OnExitManager mgr;
int *inc_1 = (int*)malloc(sizeof(*inc_1));
*inc_1 = 5;
mgr.add_callback(add, inc_1);
int *inc_2 = (int*)malloc(sizeof(*inc_2));
*inc_2 = 3;
mgr.add_callback(add, inc_2);
}
// shared between processes
static int *shared_val;
#define MAIN_SCOPE_VAL 0x1111111
static OnExitManager main_scope_mgr;
static void main_scope_cb(void *val)
{
*shared_val = *((int*)val);
}
#define EXIT_FUNC_VAL 0x22222222
static OnExitManager exit_func_mgr;
static void exit_func_cb(void *val)
{
*shared_val = *((int*)val);
}
static void call_exit()
{
exit(3);
}
int main(int argc, char **argv)
{
// test basic function scope behavior
ceph_assert(func_scope_val == 0);
func_scope();
ceph_assert(func_scope_val == 8);
// shared mem for exit tests
shared_val = (int*)mmap(NULL, sizeof(int),
PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
ceph_assert(shared_val != MAP_FAILED);
// test normal exit returning from main
*shared_val = 0;
int pid = fork();
ceph_assert(pid >= 0);
if (pid) {
int status;
int ret = waitpid(pid, &status, 0);
ceph_assert(ret == pid); // should be our child
ceph_assert(status == 0);
ceph_assert(*shared_val == MAIN_SCOPE_VAL);
} else {
// child adds a callback to the static scope callback manager and then
// exits by returning from main. The parent checks the value after the
// child exits via the memory map.
ceph_assert(*shared_val == 0);
int *new_val = (int*)malloc(sizeof(*new_val));
*new_val = MAIN_SCOPE_VAL;
main_scope_mgr.add_callback(main_scope_cb, new_val);
return 0;
}
// test exit via exit()
*shared_val = 0;
pid = fork();
ceph_assert(pid >= 0);
if (pid) {
int status;
int ret = waitpid(pid, &status, 0);
ceph_assert(ret == pid); // should be our child
ceph_assert(WEXITSTATUS(status) == 3);
ceph_assert(*shared_val == EXIT_FUNC_VAL);
} else {
// child adds a callback to the static scope callback manager and then
// exits via exit().
ceph_assert(*shared_val == 0);
int *new_val = (int*)malloc(sizeof(*new_val));
*new_val = EXIT_FUNC_VAL;
exit_func_mgr.add_callback(exit_func_cb, new_val);
call_exit();
ceph_abort();
}
return 0;
}
| 2,748 | 22.698276 | 74 |
cc
|
null |
ceph-main/src/test/perf_counters.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "include/int_types.h"
#include "include/types.h" // FIXME: ordering shouldn't be important, but right
// now, this include has to come before the others.
#include "common/perf_counters_key.h"
#include "common/perf_counters_collection.h"
#include "common/admin_socket_client.h"
#include "common/ceph_context.h"
#include "common/config.h"
#include "common/errno.h"
#include "common/safe_io.h"
#include "common/code_environment.h"
#include "global/global_context.h"
#include "global/global_init.h"
#include "include/msgr.h" // for CEPH_ENTITY_TYPE_CLIENT
#include "gtest/gtest.h"
#include <errno.h>
#include <fcntl.h>
#include <map>
#include <poll.h>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <string>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
#include <thread>
#include "common/common_init.h"
using namespace std;
int main(int argc, char **argv) {
map<string,string> defaults = {
{ "admin_socket", get_rand_socket_path() }
};
std::vector<const char*> args;
auto cct = global_init(&defaults, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE|
CINIT_FLAG_NO_CCT_PERF_COUNTERS);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
TEST(PerfCounters, SimpleTest) {
AdminSocketClient client(get_rand_socket_path());
std::string message;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\" }", &message));
ASSERT_EQ("{}\n", message);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"counter dump\" }", &message));
ASSERT_EQ("{}\n", message);
}
enum {
TEST_PERFCOUNTERS1_ELEMENT_FIRST = 200,
TEST_PERFCOUNTERS1_ELEMENT_1,
TEST_PERFCOUNTERS1_ELEMENT_2,
TEST_PERFCOUNTERS1_ELEMENT_3,
TEST_PERFCOUNTERS1_ELEMENT_LAST,
};
std::string sd(const char *c)
{
std::string ret(c);
std::string::size_type sz = ret.size();
for (std::string::size_type i = 0; i < sz; ++i) {
if (ret[i] == '\'') {
ret[i] = '\"';
}
}
return ret;
}
static PerfCounters* setup_test_perfcounters1(CephContext *cct)
{
PerfCountersBuilder bld(cct, "test_perfcounter_1",
TEST_PERFCOUNTERS1_ELEMENT_FIRST, TEST_PERFCOUNTERS1_ELEMENT_LAST);
bld.add_u64(TEST_PERFCOUNTERS1_ELEMENT_1, "element1");
bld.add_time(TEST_PERFCOUNTERS1_ELEMENT_2, "element2");
bld.add_time_avg(TEST_PERFCOUNTERS1_ELEMENT_3, "element3");
return bld.create_perf_counters();
}
TEST(PerfCounters, SinglePerfCounters) {
PerfCountersCollection *coll = g_ceph_context->get_perfcounters_collection();
PerfCounters* fake_pf = setup_test_perfcounters1(g_ceph_context);
coll->add(fake_pf);
AdminSocketClient client(get_rand_socket_path());
std::string msg;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":0,"
"\"element2\":0.000000000,\"element3\":{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}}}"), msg);
fake_pf->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf->tset(TEST_PERFCOUNTERS1_ELEMENT_2, utime_t(0, 500000000));
fake_pf->tinc(TEST_PERFCOUNTERS1_ELEMENT_3, utime_t(100, 0));
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":1,"
"\"element2\":0.500000000,\"element3\":{\"avgcount\":1,\"sum\":100.000000000,\"avgtime\":100.000000000}}}"), msg);
fake_pf->tinc(TEST_PERFCOUNTERS1_ELEMENT_3, utime_t());
fake_pf->tinc(TEST_PERFCOUNTERS1_ELEMENT_3, utime_t(20,0));
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":1,\"element2\":0.500000000,"
"\"element3\":{\"avgcount\":3,\"sum\":120.000000000,\"avgtime\":40.000000000}}}"), msg);
fake_pf->reset();
msg.clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":1,"
"\"element2\":0.000000000,\"element3\":{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}}}"), msg);
}
enum {
TEST_PERFCOUNTERS2_ELEMENT_FIRST = 400,
TEST_PERFCOUNTERS2_ELEMENT_FOO,
TEST_PERFCOUNTERS2_ELEMENT_BAR,
TEST_PERFCOUNTERS2_ELEMENT_LAST,
};
static PerfCounters* setup_test_perfcounter2(CephContext *cct)
{
PerfCountersBuilder bld(cct, "test_perfcounter_2",
TEST_PERFCOUNTERS2_ELEMENT_FIRST, TEST_PERFCOUNTERS2_ELEMENT_LAST);
bld.add_u64(TEST_PERFCOUNTERS2_ELEMENT_FOO, "foo");
bld.add_time(TEST_PERFCOUNTERS2_ELEMENT_BAR, "bar");
return bld.create_perf_counters();
}
TEST(PerfCounters, MultiplePerfCounters) {
PerfCountersCollection *coll = g_ceph_context->get_perfcounters_collection();
coll->clear();
PerfCounters* fake_pf1 = setup_test_perfcounters1(g_ceph_context);
PerfCounters* fake_pf2 = setup_test_perfcounter2(g_ceph_context);
coll->add(fake_pf1);
coll->add(fake_pf2);
AdminSocketClient client(get_rand_socket_path());
std::string msg;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":0,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1, 5);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":6,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
coll->reset(string("test_perfcounter_1"));
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":6,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1);
fake_pf1->inc(TEST_PERFCOUNTERS1_ELEMENT_1, 6);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":13,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
coll->reset(string("all"));
msg.clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":13,\"element2\":0.000000000,\"element3\":"
"{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}},\"test_perfcounter_2\":{\"foo\":0,\"bar\":0.000000000}}"), msg);
coll->remove(fake_pf2);
delete fake_pf2;
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":13,\"element2\":0.000000000,"
"\"element3\":{\"avgcount\":0,\"sum\":0.000000000,\"avgtime\":0.000000000}}}"), msg);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf schema\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"test_perfcounter_1\":{\"element1\":{\"type\":2,\"metric_type\":\"gauge\",\"value_type\":\"integer\",\"description\":\"\",\"nick\":\"\",\"priority\":0,\"units\":\"none\"},\"element2\":{\"type\":1,\"metric_type\":\"gauge\",\"value_type\":\"real\",\"description\":\"\",\"nick\":\"\",\"priority\":0,\"units\":\"none\"},\"element3\":{\"type\":5,\"metric_type\":\"gauge\",\"value_type\":\"real-integer-pair\",\"description\":\"\",\"nick\":\"\",\"priority\":0,\"units\":\"none\"}}}"), msg);
coll->clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf dump\", \"format\": \"json\" }", &msg));
ASSERT_EQ("{}", msg);
}
TEST(PerfCounters, ResetPerfCounters) {
AdminSocketClient client(get_rand_socket_path());
std::string msg;
PerfCountersCollection *coll = g_ceph_context->get_perfcounters_collection();
coll->clear();
PerfCounters* fake_pf1 = setup_test_perfcounters1(g_ceph_context);
coll->add(fake_pf1);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf reset\", \"var\": \"all\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"success\":\"perf reset all\"}"), msg);
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf reset\", \"var\": \"test_perfcounter_1\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"success\":\"perf reset test_perfcounter_1\"}"), msg);
coll->clear();
ASSERT_EQ("", client.do_request("{ \"prefix\": \"perf reset\", \"var\": \"test_perfcounter_1\", \"format\": \"json\" }", &msg));
ASSERT_EQ(sd("{\"error\":\"Not find: test_perfcounter_1\"}"), msg);
}
enum {
TEST_PERFCOUNTERS3_ELEMENT_FIRST = 400,
TEST_PERFCOUNTERS3_ELEMENT_READ,
TEST_PERFCOUNTERS3_ELEMENT_LAST,
};
static std::shared_ptr<PerfCounters> setup_test_perfcounter3(CephContext* cct) {
PerfCountersBuilder bld(cct, "test_percounter_3",
TEST_PERFCOUNTERS3_ELEMENT_FIRST, TEST_PERFCOUNTERS3_ELEMENT_LAST);
bld.add_time_avg(TEST_PERFCOUNTERS3_ELEMENT_READ, "read_avg");
std::shared_ptr<PerfCounters> p(bld.create_perf_counters());
return p;
}
static void counters_inc_test(std::shared_ptr<PerfCounters> fake_pf) {
int i = 100000;
utime_t t;
// set to 1 nsec
t.set_from_double(0.000000001);
while (i--) {
// increase by one, make sure data.u64 equal to data.avgcount
fake_pf->tinc(TEST_PERFCOUNTERS3_ELEMENT_READ, t);
}
}
static void counters_readavg_test(std::shared_ptr<PerfCounters> fake_pf) {
int i = 100000;
while (i--) {
std::pair<uint64_t, uint64_t> dat = fake_pf->get_tavg_ns(TEST_PERFCOUNTERS3_ELEMENT_READ);
// sum and count should be identical as we increment TEST_PERCOUNTERS_ELEMENT_READ by 1 nsec eveytime
ASSERT_EQ(dat.first, dat.second);
}
}
TEST(PerfCounters, read_avg) {
std::shared_ptr<PerfCounters> fake_pf = setup_test_perfcounter3(g_ceph_context);
std::thread t1(counters_inc_test, fake_pf);
std::thread t2(counters_readavg_test, fake_pf);
t2.join();
t1.join();
}
static PerfCounters* setup_test_perfcounter4(std::string name, CephContext *cct)
{
PerfCountersBuilder bld(cct, name,
TEST_PERFCOUNTERS2_ELEMENT_FIRST, TEST_PERFCOUNTERS2_ELEMENT_LAST);
bld.add_u64(TEST_PERFCOUNTERS2_ELEMENT_FOO, "foo");
bld.add_time(TEST_PERFCOUNTERS2_ELEMENT_BAR, "bar");
PerfCounters* counters = bld.create_perf_counters();
cct->get_perfcounters_collection()->add(counters);
return counters;
}
TEST(PerfCounters, TestLabeledCountersOnly) {
constexpr std::string_view empty_dump_format_raw = R"({}
)";
std::string counter_key1 = ceph::perf_counters::key_create("name1", {{"label1", "val1"}});
std::string counter_key2 = ceph::perf_counters::key_create("name2", {{"label2", "val2"}});
std::string counter_key3 = ceph::perf_counters::key_create("name1", {{"label1", "val3"}});
PerfCounters* counters1 = setup_test_perfcounter4(counter_key1, g_ceph_context);
PerfCounters* counters2 = setup_test_perfcounter4(counter_key2, g_ceph_context);
PerfCounters* counters3 = setup_test_perfcounter4(counter_key3, g_ceph_context);
counters1->inc(TEST_PERFCOUNTERS2_ELEMENT_FOO, 3);
counters1->dec(TEST_PERFCOUNTERS2_ELEMENT_FOO, 1);
counters2->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 4);
counters3->inc(TEST_PERFCOUNTERS2_ELEMENT_FOO, 3);
AdminSocketClient client(get_rand_socket_path());
std::string message;
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter dump", "format": "raw" })", &message));
ASSERT_EQ(R"({
"name1": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": 2,
"bar": 0.000000000
}
},
{
"labels": {
"label1": "val3"
},
"counters": {
"foo": 3,
"bar": 0.000000000
}
}
],
"name2": [
{
"labels": {
"label2": "val2"
},
"counters": {
"foo": 4,
"bar": 0.000000000
}
}
]
}
)", message);
// make sure labeled counters are not in normal perf dump
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf dump", "format": "raw" })", &message));
ASSERT_EQ(empty_dump_format_raw, message);
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter schema", "format": "raw" })", &message));
ASSERT_EQ(R"({
"name1": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
},
{
"labels": {
"label1": "val3"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"name2": [
{
"labels": {
"label2": "val2"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
]
}
)", message);
// make sure labeled counters are not in normal perf schema
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf schema", "format": "raw" })", &message));
ASSERT_EQ(empty_dump_format_raw, message);
g_ceph_context->get_perfcounters_collection()->clear();
}
TEST(PerfCounters, TestLabelStrings) {
AdminSocketClient client(get_rand_socket_path());
std::string message;
// test empty val in a label pair will get the label pair added but empty key will not
std::string counter_key1 = ceph::perf_counters::key_create("good_ctrs", {{"label3", "val4"}, {"label1", ""}});
PerfCounters* counters1 = setup_test_perfcounter4(counter_key1, g_ceph_context);
std::string counter_key2 = ceph::perf_counters::key_create("bad_ctrs", {{"", "val4"}, {"label1", "val1"}});
PerfCounters* counters2 = setup_test_perfcounter4(counter_key2, g_ceph_context);
counters1->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 2);
counters2->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 4);
// test empty keys in each of the label pairs will get only the labels section added
std::string counter_key3 = ceph::perf_counters::key_create("bad_ctrs2", {{"", "val2"}, {"", "val33"}});
PerfCounters* counters3 = setup_test_perfcounter4(counter_key3, g_ceph_context);
counters3->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 6);
// a key with a somehow odd number of entries after the the key name will omit final unfinished label pair
std::string counter_key4 = "too_many_delimiters";
counter_key4 += '\0';
counter_key4 += "label1";
counter_key4 += '\0';
counter_key4 += "val1";
counter_key4 += '\0';
counter_key4 += "label2";
counter_key4 += '\0';
PerfCounters* counters4 = setup_test_perfcounter4(counter_key4, g_ceph_context);
counters4->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 8);
// test unlabeled perf counters are in the counter dump with labels and counters sections
std::string counter_key5 = "only_key";
PerfCounters* no_label_counters = setup_test_perfcounter4(counter_key5, g_ceph_context);
no_label_counters->set(TEST_PERFCOUNTERS2_ELEMENT_FOO, 4);
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter dump", "format": "raw" })", &message));
ASSERT_EQ(R"({
"bad_ctrs": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": 4,
"bar": 0.000000000
}
}
],
"bad_ctrs2": [
{
"labels": {},
"counters": {
"foo": 6,
"bar": 0.000000000
}
}
],
"good_ctrs": [
{
"labels": {
"label1": "",
"label3": "val4"
},
"counters": {
"foo": 2,
"bar": 0.000000000
}
}
],
"only_key": [
{
"labels": {},
"counters": {
"foo": 4,
"bar": 0.000000000
}
}
],
"too_many_delimiters": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": 8,
"bar": 0.000000000
}
}
]
}
)", message);
// test unlabeled perf counters are in the schema dump with labels and counters sections
ASSERT_EQ("", client.do_request(R"({ "prefix": "counter schema", "format": "raw" })", &message));
ASSERT_EQ(R"({
"bad_ctrs": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"bad_ctrs2": [
{
"labels": {},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"good_ctrs": [
{
"labels": {
"label1": "",
"label3": "val4"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"only_key": [
{
"labels": {},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
],
"too_many_delimiters": [
{
"labels": {
"label1": "val1"
},
"counters": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
]
}
)", message);
// test unlabeled perf counters are in the perf dump without the labels and counters section
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf dump", "format": "raw" })", &message));
ASSERT_EQ(R"({
"only_key": {
"foo": 4,
"bar": 0.000000000
}
}
)", message);
// test unlabeled perf counters are in the perf schema without the labels and counters section
ASSERT_EQ("", client.do_request(R"({ "prefix": "perf schema", "format": "raw" })", &message));
ASSERT_EQ(R"({
"only_key": {
"foo": {
"type": 2,
"metric_type": "gauge",
"value_type": "integer",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
},
"bar": {
"type": 1,
"metric_type": "gauge",
"value_type": "real",
"description": "",
"nick": "",
"priority": 0,
"units": "none"
}
}
}
)", message);
g_ceph_context->get_perfcounters_collection()->clear();
}
| 23,801 | 33.34632 | 502 |
cc
|
null |
ceph-main/src/test/perf_helper.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/* Copyright (c) 2011 Facebook
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "include/buffer.h"
#include "common/error_code.h"
using namespace ceph;
namespace PerfHelper {
/// Flush the CPU data cache by reading and writing 100MB of new data.
void flush_cache()
{
int hundredMegs = 100 * 1024 * 1024;
volatile char* block = new char[hundredMegs];
for (int i = 0; i < hundredMegs; i++)
block[i] = 1;
delete[] block;
}
/// Used in functionCall().
uint64_t plus_one(uint64_t x)
{
return x + 1;
}
/// Used in throwIntNL.
void throw_int()
{
throw 0;
}
/// Used in throwExceptionNL.
void throw_end_of_buffer()
{
throw buffer::end_of_buffer();
}
}
| 1,477 | 26.886792 | 77 |
cc
|
null |
ceph-main/src/test/perf_helper.h
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/* Copyright (c) 2011 Facebook
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef CEPH_TEST_PERFHELPER_H
#define CEPH_TEST_PERFHELPER_H
namespace PerfHelper {
void flush_cache();
uint64_t plus_one(uint64_t x);
void throw_end_of_buffer();
void throw_int();
} // PerfHelper
#endif // CEPH_TEST_PERFHELPER_H
| 1,098 | 34.451613 | 77 |
h
|
null |
ceph-main/src/test/perf_local.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/* Copyright (c) 2015 Haomai Wang <[email protected]>
* Copyright (c) 2011-2014 Stanford University
* Copyright (c) 2011 Facebook
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
// This program contains a collection of low-level performance measurements
// for Ceph, which can be run either individually or altogether. These
// tests measure performance in a single stand-alone process, not in a cluster
// with multiple servers. Invoke the program like this:
//
// Perf test1 test2 ...
//
// test1 and test2 are the names of individual performance measurements to
// run. If no test names are provided then all of the performance tests
// are run.
//
// To add a new test:
// * Write a function that implements the test. Use existing test functions
// as a guideline, and be sure to generate output in the same form as
// other tests.
// * Create a new entry for the test in the #tests table.
#include <vector>
#include <sched.h>
#include "acconfig.h"
#ifdef HAVE_SSE
#include <xmmintrin.h>
#endif
#include "include/buffer.h"
#include "include/encoding.h"
#include "include/ceph_hash.h"
#include "include/spinlock.h"
#include "common/ceph_argparse.h"
#include "common/Cycles.h"
#include "common/Cond.h"
#include "common/ceph_mutex.h"
#include "common/Thread.h"
#include "common/Timer.h"
#include "msg/async/Event.h"
#include "global/global_init.h"
#include "test/perf_helper.h"
#include <atomic>
using namespace std;
using namespace ceph;
/**
* Ask the operating system to pin the current thread to a given CPU.
*
* \param cpu
* Indicates the desired CPU and hyperthread; low order 2 bits
* specify CPU, next bit specifies hyperthread.
*/
void bind_thread_to_cpu(int cpu)
{
#ifdef HAVE_SCHED
cpu_set_t set;
CPU_ZERO(&set);
CPU_SET(cpu, &set);
sched_setaffinity(0, sizeof(set), &set);
#endif
}
/*
* This function just discards its argument. It's used to make it
* appear that data is used, so that the compiler won't optimize
* away the code we're trying to measure.
*
* \param value
* Pointer to arbitrary value; it's discarded.
*/
void discard(void* value) {
int x = *reinterpret_cast<int*>(value);
if (x == 0x43924776) {
printf("Value was 0x%x\n", x);
}
}
//----------------------------------------------------------------------
// Test functions start here
//----------------------------------------------------------------------
// Measure the cost of atomic compare-and-swap
double atomic_int_cmp()
{
int count = 1000000;
std::atomic<unsigned> value = { 11 };
unsigned int test = 11;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
value.compare_exchange_strong(test, test+2);
test += 2;
}
uint64_t stop = Cycles::rdtsc();
// printf("Final value: %d\n", value.load());
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of incrementing an atomic
double atomic_int_inc()
{
int count = 1000000;
std::atomic<int64_t> value = { 11 };
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
value++;
}
uint64_t stop = Cycles::rdtsc();
// printf("Final value: %d\n", value.load());
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of reading an atomic
double atomic_int_read()
{
int count = 1000000;
std::atomic<int64_t> value = { 11 };
[[maybe_unused]] int total = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
total += value;
}
uint64_t stop = Cycles::rdtsc();
// printf("Total: %d\n", total);
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of storing a new value in an atomic
double atomic_int_set()
{
int count = 1000000;
std::atomic<int64_t> value = { 11 };
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
value = 88;
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of acquiring and releasing a mutex in the
// fast case where the mutex is free.
double mutex_nonblock()
{
int count = 1000000;
ceph::mutex m = ceph::make_mutex("mutex_nonblock::m");
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
m.lock();
m.unlock();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of allocating and deallocating a buffer, plus
// appending (logically) one ptr.
double buffer_basic()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
bufferptr ptr("abcdefg", 7);
for (int i = 0; i < count; i++) {
bufferlist b;
b.append(ptr, 0, 5);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
struct DummyBlock {
int a = 1, b = 2, c = 3, d = 4;
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
encode(a, bl);
encode(b, bl);
encode(c, bl);
encode(d, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(a, bl);
decode(b, bl);
decode(c, bl);
decode(d, bl);
DECODE_FINISH(bl);
}
};
WRITE_CLASS_ENCODER(DummyBlock)
// Measure the cost of encoding and decoding a buffer, plus
// allocating space for one chunk.
double buffer_encode_decode()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
bufferlist b;
DummyBlock dummy_block;
encode(dummy_block, b);
auto iter = b.cbegin();
decode(dummy_block, iter);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of allocating and deallocating a buffer, plus
// copying in a small block.
double buffer_basic_copy()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
bufferlist b;
b.append("abcdefg", 6);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of making a copy of parts of two ptrs.
double buffer_copy()
{
int count = 1000000;
bufferlist b;
b.append("abcde", 5);
b.append("01234", 5);
char copy[10];
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
b.cbegin(2).copy(6, copy);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of allocating new space by extending the
// bufferlist
double buffer_encode()
{
int count = 100000;
uint64_t total = 0;
for (int i = 0; i < count; i++) {
bufferlist b;
DummyBlock dummy_block;
encode(dummy_block, b);
uint64_t start = Cycles::rdtsc();
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
encode(dummy_block, b);
total += Cycles::rdtsc() - start;
}
return Cycles::to_seconds(total)/(count*10);
}
// Measure the cost of creating an iterator and iterating over 10
// chunks in a buffer.
double buffer_iterator()
{
bufferlist b;
const char s[] = "abcdefghijklmnopqrstuvwxyz";
bufferptr ptr(s, sizeof(s));
for (int i = 0; i < 5; i++) {
b.append(ptr, i, 5);
}
int count = 100000;
int sum = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
auto it = b.cbegin();
while (!it.end()) {
sum += (static_cast<const char*>(it.get_current_ptr().c_str()))[it.get_remaining()-1];
++it;
}
}
uint64_t stop = Cycles::rdtsc();
discard(&sum);
return Cycles::to_seconds(stop - start)/count;
}
// Implements the CondPingPong test.
class CondPingPong {
ceph::mutex mutex = ceph::make_mutex("CondPingPong::mutex");
ceph::condition_variable cond;
int prod = 0;
int cons = 0;
const int count = 10000;
class Consumer : public Thread {
CondPingPong *p;
public:
explicit Consumer(CondPingPong *p): p(p) {}
void* entry() override {
p->consume();
return 0;
}
} consumer;
public:
CondPingPong(): consumer(this) {}
double run() {
consumer.create("consumer");
uint64_t start = Cycles::rdtsc();
produce();
uint64_t stop = Cycles::rdtsc();
consumer.join();
return Cycles::to_seconds(stop - start)/count;
}
void produce() {
std::unique_lock l{mutex};
while (cons < count) {
cond.wait(l, [this] { return cons >= prod; });
++prod;
cond.notify_all();
}
}
void consume() {
std::unique_lock l{mutex};
while (cons < count) {
cond.wait(l, [this] { return cons != prod; });
++cons;
cond.notify_all();
}
}
};
// Measure the cost of coordinating between threads using a condition variable.
double cond_ping_pong()
{
return CondPingPong().run();
}
// Measure the cost of a 32-bit divide. Divides don't take a constant
// number of cycles. Values were chosen here semi-randomly to depict a
// fairly expensive scenario. Someone with fancy ALU knowledge could
// probably pick worse values.
double div32()
{
#if defined(__i386__) || defined(__x86_64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
// NB: Expect an x86 processor exception is there's overflow.
uint32_t numeratorHi = 0xa5a5a5a5U;
uint32_t numeratorLo = 0x55aa55aaU;
uint32_t divisor = 0xaa55aa55U;
uint32_t quotient;
uint32_t remainder;
for (int i = 0; i < count; i++) {
__asm__ __volatile__("div %4" :
"=a"(quotient), "=d"(remainder) :
"a"(numeratorLo), "d"(numeratorHi), "r"(divisor) :
"cc");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#elif defined(__aarch64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
uint64_t numerator = 0xa5a5a5a555aa55aaUL;
uint32_t divisor = 0xaa55aa55U;
uint32_t result;
for (int i = 0; i < count; i++) {
asm volatile("udiv %0, %1, %2" : "=r"(result) :
"r"(numerator), "r"(divisor));
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of a 64-bit divide. Divides don't take a constant
// number of cycles. Values were chosen here semi-randomly to depict a
// fairly expensive scenario. Someone with fancy ALU knowledge could
// probably pick worse values.
double div64()
{
#if defined(__x86_64__) || defined(__amd64__)
int count = 1000000;
// NB: Expect an x86 processor exception is there's overflow.
uint64_t start = Cycles::rdtsc();
uint64_t numeratorHi = 0x5a5a5a5a5a5UL;
uint64_t numeratorLo = 0x55aa55aa55aa55aaUL;
uint64_t divisor = 0xaa55aa55aa55aa55UL;
uint64_t quotient;
uint64_t remainder;
for (int i = 0; i < count; i++) {
__asm__ __volatile__("divq %4" :
"=a"(quotient), "=d"(remainder) :
"a"(numeratorLo), "d"(numeratorHi), "r"(divisor) :
"cc");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of calling a non-inlined function.
double function_call()
{
int count = 1000000;
uint64_t x = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
x = PerfHelper::plus_one(x);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the minimum cost of EventCenter::process_events, when there are no
// Pollers and no Timers.
double eventcenter_poll()
{
int count = 1000000;
EventCenter center(g_ceph_context);
center.init(1000, 0, "posix");
center.set_owner();
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
center.process_events(0);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
class CenterWorker : public Thread {
CephContext *cct;
bool done;
public:
EventCenter center;
explicit CenterWorker(CephContext *c): cct(c), done(false), center(c) {
center.init(100, 0, "posix");
}
void stop() {
done = true;
center.wakeup();
}
void* entry() override {
center.set_owner();
bind_thread_to_cpu(2);
while (!done)
center.process_events(1000);
return 0;
}
};
class CountEvent: public EventCallback {
std::atomic<int64_t> *count;
public:
explicit CountEvent(std::atomic<int64_t> *atomic): count(atomic) {}
void do_request(uint64_t id) override {
(*count)--;
}
};
double eventcenter_dispatch()
{
int count = 100000;
CenterWorker worker(g_ceph_context);
std::atomic<int64_t> flag = { 1 };
worker.create("evt_center_disp");
EventCallbackRef count_event(new CountEvent(&flag));
worker.center.dispatch_event_external(count_event);
// Start a new thread and wait for it to ready.
while (flag)
usleep(100);
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
flag = 1;
worker.center.dispatch_event_external(count_event);
while (flag)
;
}
uint64_t stop = Cycles::rdtsc();
worker.stop();
worker.join();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of copying a given number of bytes with memcpy.
double memcpy_shared(size_t size)
{
int count = 1000000;
char src[size], dst[size];
memset(src, 0, sizeof(src));
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
memcpy(dst, src, size);
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
double memcpy100()
{
return memcpy_shared(100);
}
double memcpy1000()
{
return memcpy_shared(1000);
}
double memcpy10000()
{
return memcpy_shared(10000);
}
// Benchmark rjenkins hashing performance on cached data.
template <int key_length>
double ceph_str_hash_rjenkins()
{
int count = 100000;
char buf[key_length];
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++)
ceph_str_hash(CEPH_STR_HASH_RJENKINS, buf, sizeof(buf));
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of reading the fine-grain cycle counter.
double rdtsc_test()
{
int count = 1000000;
uint64_t start = Cycles::rdtsc();
[[maybe_unused]] uint64_t total = 0;
for (int i = 0; i < count; i++) {
total += Cycles::rdtsc();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of the Cycles::to_seconds method.
double perf_cycles_to_seconds()
{
int count = 1000000;
[[maybe_unused]] double total = 0;
uint64_t cycles = 994261;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
total += Cycles::to_seconds(cycles);
}
uint64_t stop = Cycles::rdtsc();
// printf("Result: %.4f\n", total/count);
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of the Cylcles::toNanoseconds method.
double perf_cycles_to_nanoseconds()
{
int count = 1000000;
[[maybe_unused]] uint64_t total = 0;
uint64_t cycles = 994261;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
total += Cycles::to_nanoseconds(cycles);
}
uint64_t stop = Cycles::rdtsc();
// printf("Result: %lu\n", total/count);
return Cycles::to_seconds(stop - start)/count;
}
#ifdef HAVE_SSE
/**
* Prefetch the cache lines containing [object, object + numBytes) into the
* processor's caches.
* The best docs for this are in the Intel instruction set reference under
* PREFETCH.
* \param object
* The start of the region of memory to prefetch.
* \param num_bytes
* The size of the region of memory to prefetch.
*/
static inline void prefetch(const void *object, uint64_t num_bytes)
{
uint64_t offset = reinterpret_cast<uint64_t>(object) & 0x3fUL;
const char* p = reinterpret_cast<const char*>(object) - offset;
for (uint64_t i = 0; i < offset + num_bytes; i += 64)
_mm_prefetch(p + i, _MM_HINT_T0);
}
#elif defined(__aarch64__)
static inline void prefetch(const void *object, uint64_t num_bytes)
{
uint64_t offset = reinterpret_cast<uint64_t>(object) & 0x3fUL;
const char* ptr = reinterpret_cast<const char*>(object) - offset;
for (uint64_t i = 0; i < offset + num_bytes; i += 64, ptr += 64)
asm volatile("prfm pldl1keep, %a0\n" : : "p" (ptr));
}
#endif
// Measure the cost of the prefetch instruction.
double perf_prefetch()
{
#if defined(HAVE_SSE) || defined(__aarch64__)
uint64_t total_ticks = 0;
int count = 10;
char buf[16 * 64];
for (int i = 0; i < count; i++) {
PerfHelper::flush_cache();
uint64_t start = Cycles::rdtsc();
prefetch(&buf[576], 64);
prefetch(&buf[0], 64);
prefetch(&buf[512], 64);
prefetch(&buf[960], 64);
prefetch(&buf[640], 64);
prefetch(&buf[896], 64);
prefetch(&buf[256], 64);
prefetch(&buf[704], 64);
prefetch(&buf[320], 64);
prefetch(&buf[384], 64);
prefetch(&buf[128], 64);
prefetch(&buf[448], 64);
prefetch(&buf[768], 64);
prefetch(&buf[832], 64);
prefetch(&buf[64], 64);
prefetch(&buf[192], 64);
uint64_t stop = Cycles::rdtsc();
total_ticks += stop - start;
}
return Cycles::to_seconds(total_ticks) / count / 16;
#else
return -1;
#endif
}
#if defined(__x86_64__)
/**
* This function is used to seralize machine instructions so that no
* instructions that appear after it in the current thread can run before any
* instructions that appear before it.
*
* It is useful for putting around rdpmc instructions (to pinpoint cache
* misses) as well as before rdtsc instructions, to prevent time pollution from
* instructions supposed to be executing before the timer starts.
*/
static inline void serialize() {
uint32_t eax, ebx, ecx, edx;
__asm volatile("cpuid"
: "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
: "a" (1U));
}
#endif
// Measure the cost of cpuid
double perf_serialize() {
#if defined(__x86_64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
serialize();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of an lfence instruction.
double lfence()
{
#ifdef HAVE_SSE2
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
__asm__ __volatile__("lfence" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#elif defined(__aarch64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
asm volatile("dmb ishld" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of an sfence instruction.
double sfence()
{
#ifdef HAVE_SSE
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
__asm__ __volatile__("sfence" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#elif defined(__aarch64__)
int count = 1000000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
asm volatile("dmb ishst" ::: "memory");
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
#else
return -1;
#endif
}
// Measure the cost of acquiring and releasing a SpinLock (assuming the
// lock is initially free).
double test_spinlock()
{
int count = 1000000;
ceph::spinlock lock;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
lock.lock();
lock.unlock();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Helper for spawn_thread. This is the main function that the thread executes
// (intentionally empty).
class ThreadHelper : public Thread {
void *entry() override { return 0; }
};
// Measure the cost of start and joining with a thread.
double spawn_thread()
{
int count = 10000;
ThreadHelper thread;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
thread.create("thread_helper");
thread.join();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
class FakeContext : public Context {
public:
void finish(int r) override {}
};
// Measure the cost of starting and stopping a Dispatch::Timer.
double perf_timer()
{
int count = 1000000;
ceph::mutex lock = ceph::make_mutex("perf_timer::lock");
SafeTimer timer(g_ceph_context, lock);
FakeContext **c = new FakeContext*[count];
for (int i = 0; i < count; i++) {
c[i] = new FakeContext();
}
uint64_t start = Cycles::rdtsc();
std::lock_guard l{lock};
for (int i = 0; i < count; i++) {
if (timer.add_event_after(12345, c[i])) {
timer.cancel_event(c[i]);
}
}
uint64_t stop = Cycles::rdtsc();
delete[] c;
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an int. This uses an integer as
// the value thrown, which is presumably as fast as possible.
double throw_int()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
throw 0;
} catch (int) { // NOLINT
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an int from a function call.
double throw_int_call()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
PerfHelper::throw_int();
} catch (int) { // NOLINT
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an Exception. This uses an actual
// exception as the value thrown, which may be slower than throwInt.
double throw_exception()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
throw buffer::end_of_buffer();
} catch (const buffer::end_of_buffer&) {
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of throwing and catching an Exception from a function call.
double throw_exception_call()
{
int count = 10000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
try {
PerfHelper::throw_end_of_buffer();
} catch (const buffer::end_of_buffer&) {
// pass
}
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// Measure the cost of pushing a new element on a std::vector, copying
// from the end to an internal element, and popping the end element.
double vector_push_pop()
{
int count = 100000;
std::vector<int> vector;
vector.push_back(1);
vector.push_back(2);
vector.push_back(3);
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
vector.push_back(i);
vector.push_back(i+1);
vector.push_back(i+2);
vector[2] = vector.back();
vector.pop_back();
vector[0] = vector.back();
vector.pop_back();
vector[1] = vector.back();
vector.pop_back();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/(count*3);
}
// Measure the cost of ceph_clock_now
double perf_ceph_clock_now()
{
int count = 100000;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
ceph_clock_now();
}
uint64_t stop = Cycles::rdtsc();
return Cycles::to_seconds(stop - start)/count;
}
// The following struct and table define each performance test in terms of
// a string name and a function that implements the test.
struct TestInfo {
const char* name; // Name of the performance test; this is
// what gets typed on the command line to
// run the test.
double (*func)(); // Function that implements the test;
// returns the time (in seconds) for each
// iteration of that test.
const char *description; // Short description of this test (not more
// than about 40 characters, so the entire
// test output fits on a single line).
};
TestInfo tests[] = {
{"atomic_int_cmp", atomic_int_cmp,
"atomic_t::compare_and_swap"},
{"atomic_int_inc", atomic_int_inc,
"atomic_t::inc"},
{"atomic_int_read", atomic_int_read,
"atomic_t::read"},
{"atomic_int_set", atomic_int_set,
"atomic_t::set"},
{"mutex_nonblock", mutex_nonblock,
"Mutex lock/unlock (no blocking)"},
{"buffer_basic", buffer_basic,
"buffer create, add one ptr, delete"},
{"buffer_encode_decode", buffer_encode_decode,
"buffer create, encode/decode object, delete"},
{"buffer_basic_copy", buffer_basic_copy,
"buffer create, copy small block, delete"},
{"buffer_copy", buffer_copy,
"copy out 2 small ptrs from buffer"},
{"buffer_encode10", buffer_encode,
"buffer encoding 10 structures onto existing ptr"},
{"buffer_iterator", buffer_iterator,
"iterate over buffer with 5 ptrs"},
{"cond_ping_pong", cond_ping_pong,
"condition variable round-trip"},
{"div32", div32,
"32-bit integer division instruction"},
{"div64", div64,
"64-bit integer division instruction"},
{"function_call", function_call,
"Call a function that has not been inlined"},
{"eventcenter_poll", eventcenter_poll,
"EventCenter::process_events (no timers or events)"},
{"eventcenter_dispatch", eventcenter_dispatch,
"EventCenter::dispatch_event_external latency"},
{"memcpy100", memcpy100,
"Copy 100 bytes with memcpy"},
{"memcpy1000", memcpy1000,
"Copy 1000 bytes with memcpy"},
{"memcpy10000", memcpy10000,
"Copy 10000 bytes with memcpy"},
{"ceph_str_hash_rjenkins", ceph_str_hash_rjenkins<16>,
"rjenkins hash on 16 byte of data"},
{"ceph_str_hash_rjenkins", ceph_str_hash_rjenkins<256>,
"rjenkins hash on 256 bytes of data"},
{"rdtsc", rdtsc_test,
"Read the fine-grain cycle counter"},
{"cycles_to_seconds", perf_cycles_to_seconds,
"Convert a rdtsc result to (double) seconds"},
{"cycles_to_seconds", perf_cycles_to_nanoseconds,
"Convert a rdtsc result to (uint64_t) nanoseconds"},
{"prefetch", perf_prefetch,
"Prefetch instruction"},
{"serialize", perf_serialize,
"serialize instruction"},
{"lfence", lfence,
"Lfence instruction"},
{"sfence", sfence,
"Sfence instruction"},
{"spin_lock", test_spinlock,
"Acquire/release SpinLock"},
{"spawn_thread", spawn_thread,
"Start and stop a thread"},
{"perf_timer", perf_timer,
"Insert and cancel a SafeTimer"},
{"throw_int", throw_int,
"Throw an int"},
{"throw_int_call", throw_int_call,
"Throw an int in a function call"},
{"throw_exception", throw_exception,
"Throw an Exception"},
{"throw_exception_call", throw_exception_call,
"Throw an Exception in a function call"},
{"vector_push_pop", vector_push_pop,
"Push and pop a std::vector"},
{"ceph_clock_now", perf_ceph_clock_now,
"ceph_clock_now function"},
};
/**
* Runs a particular test and prints a one-line result message.
*
* \param info
* Describes the test to run.
*/
void run_test(TestInfo& info)
{
double secs = info.func();
int width = printf("%-24s ", info.name);
if (secs == -1) {
width += printf(" architecture nonsupport ");
} else if (secs < 1.0e-06) {
width += printf("%8.2fns", 1e09*secs);
} else if (secs < 1.0e-03) {
width += printf("%8.2fus", 1e06*secs);
} else if (secs < 1.0) {
width += printf("%8.2fms", 1e03*secs);
} else {
width += printf("%8.2fs", secs);
}
printf("%*s %s\n", 32-width, "", info.description);
}
int main(int argc, char *argv[])
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
Cycles::init();
bind_thread_to_cpu(3);
if (argc == 1) {
// No test names specified; run all tests.
for (size_t i = 0; i < sizeof(tests)/sizeof(TestInfo); ++i) {
run_test(tests[i]);
}
} else {
// Run only the tests that were specified on the command line.
for (int i = 1; i < argc; i++) {
bool found_test = false;
for (size_t j = 0; j < sizeof(tests)/sizeof(TestInfo); ++j) {
if (strcmp(argv[i], tests[j].name) == 0) {
found_test = true;
run_test(tests[j]);
break;
}
}
if (!found_test) {
int width = printf("%-24s ??", argv[i]);
printf("%*s No such test\n", 32-width, "");
}
}
}
}
| 29,610 | 26.725655 | 92 |
cc
|
null |
ceph-main/src/test/rbd-ggate.sh
|
#!/usr/bin/env bash
#
# Copyright (C) 2014, 2015 Red Hat <[email protected]>
# Copyright (C) 2013 Cloudwatt <[email protected]>
#
# Author: Loic Dachary <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Library Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library Public License for more details.
#
set -ex
source $(dirname $0)/detect-build-env-vars.sh
test `uname` = FreeBSD
CEPH_CLI_TEST_DUP_COMMAND=1 \
MON=1 OSD=3 MDS=0 MGR=1 CEPH_PORT=7206 $CEPH_ROOT/src/test/vstart_wrapper.sh \
$CEPH_ROOT/qa/workunits/rbd/rbd-ggate.sh \
| 901 | 33.692308 | 78 |
sh
|
null |
ceph-main/src/test/run-rbd-unit-tests.sh
|
#!/usr/bin/env bash
set -ex
# this should be run from the src directory in the ceph.git
source $(dirname $0)/detect-build-env-vars.sh
PATH="$CEPH_BIN:$PATH"
if [ $# = 0 ]; then
# mimic the old behaviour
TESTS='0 1 61 109 127'
unset RBD_FEATURES; unittest_librbd
elif [ $# = 1 -a "${1}" = N ] ; then
# new style no feature request
unset RBD_FEATURES; unittest_librbd
else
TESTS="$*"
fi
for i in ${TESTS}
do
RBD_FEATURES=$i unittest_librbd
done
echo OK
| 473 | 17.230769 | 59 |
sh
|
null |
ceph-main/src/test/run-rbd-valgrind-unit-tests.sh
|
#!/usr/bin/env bash
set -ex
# this should be run from the src directory in the ceph.git (when built with
# automake) or cmake build directory
source $(dirname $0)/detect-build-env-vars.sh
RBD_FEATURES=13 valgrind --tool=memcheck --leak-check=full --error-exitcode=1 \
--suppressions=${CEPH_ROOT}/qa/valgrind.supp unittest_librbd
echo OK
| 346 | 25.692308 | 79 |
sh
|
null |
ceph-main/src/test/run_cmd.cc
|
#include "common/config.h"
#include "common/run_cmd.h"
#include "gtest/gtest.h"
#include <stdlib.h>
#include <unistd.h>
TEST(RunCommand, StringSimple)
{
char temp_file_name[] = "run_cmd_temp_file_XXXXXX";
int fd = ::mkstemp(temp_file_name);
ASSERT_GE(fd, 0);
::close(fd);
std::string ret = run_cmd("touch", temp_file_name, (char*)NULL);
ASSERT_EQ(ret, "");
ASSERT_EQ(access(temp_file_name, R_OK), 0);
ret = run_cmd("rm", "-f", temp_file_name, (char*)NULL);
ASSERT_EQ(ret, "");
ASSERT_NE(access(temp_file_name, R_OK), 0);
}
| 551 | 19.444444 | 66 |
cc
|
null |
ceph-main/src/test/signals.cc
|
#include "common/config.h"
#include "common/signal.h"
#include "global/signal_handler.h"
#include "common/debug.h"
#include "include/coredumpctl.h"
#include "gtest/gtest.h"
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include "include/ceph_assert.h"
#define dout_context g_ceph_context
static volatile sig_atomic_t got_sigusr1 = 0;
static void handle_sigusr1(int signo)
{
got_sigusr1 = 1;
}
TEST(SignalApi, SimpleInstall)
{
install_sighandler(SIGPIPE, handle_sigusr1, 0);
}
TEST(SignalApi, SimpleInstallAndTest)
{
install_sighandler(SIGPIPE, handle_sigusr1, 0);
// SIGPIPE starts out blocked
int ret = kill(getpid(), SIGPIPE);
ASSERT_EQ(ret, 0);
ASSERT_EQ(got_sigusr1, 0);
// handle SIGPIPE
sigset_t mask;
sigemptyset(&mask);
ret = sigsuspend(&mask);
if (ret == -1)
ret = errno;
// we should have gotten it
ASSERT_EQ(ret, EINTR);
ASSERT_EQ(got_sigusr1, 1);
}
TEST(SignalEffects, ErrnoTest1)
{
}
bool usr1 = false;
bool usr2 = false;
void reset()
{
usr1 = false;
usr2 = false;
}
void testhandler(int signal)
{
switch (signal) {
case SIGUSR1:
usr1 = true;
break;
case SIGUSR2:
usr2 = true;
break;
default:
ceph_abort_msg("unexpected signal");
}
}
TEST(SignalHandler, Single)
{
reset();
init_async_signal_handler();
register_async_signal_handler(SIGUSR1, testhandler);
ASSERT_TRUE(usr1 == false);
int ret = kill(getpid(), SIGUSR1);
ASSERT_EQ(ret, 0);
sleep(1);
ASSERT_TRUE(usr1 == true);
unregister_async_signal_handler(SIGUSR1, testhandler);
shutdown_async_signal_handler();
}
TEST(SignalHandler, Multiple)
{
int ret;
reset();
init_async_signal_handler();
register_async_signal_handler(SIGUSR1, testhandler);
register_async_signal_handler(SIGUSR2, testhandler);
ASSERT_TRUE(usr1 == false);
ASSERT_TRUE(usr2 == false);
ret = kill(getpid(), SIGUSR1);
ASSERT_EQ(ret, 0);
ret = kill(getpid(), SIGUSR2);
ASSERT_EQ(ret, 0);
sleep(1);
ASSERT_TRUE(usr1 == true);
ASSERT_TRUE(usr2 == true);
unregister_async_signal_handler(SIGUSR1, testhandler);
unregister_async_signal_handler(SIGUSR2, testhandler);
shutdown_async_signal_handler();
}
TEST(SignalHandler, LogInternal)
{
g_ceph_context->_log->inject_segv();
{
PrCtl unset_dumpable;
ASSERT_DEATH(derr << "foo" << dendl, ".*");
}
g_ceph_context->_log->reset_segv();
}
/*
TEST(SignalHandler, MultipleBigFd)
{
int ret;
for (int i = 0; i < 1500; i++)
::open(".", O_RDONLY);
reset();
init_async_signal_handler();
register_async_signal_handler(SIGUSR1, testhandler);
register_async_signal_handler(SIGUSR2, testhandler);
ASSERT_TRUE(usr1 == false);
ASSERT_TRUE(usr2 == false);
ret = kill(getpid(), SIGUSR1);
ASSERT_EQ(ret, 0);
ret = kill(getpid(), SIGUSR2);
ASSERT_EQ(ret, 0);
sleep(1);
ASSERT_TRUE(usr1 == true);
ASSERT_TRUE(usr2 == true);
unregister_async_signal_handler(SIGUSR1, testhandler);
unregister_async_signal_handler(SIGUSR2, testhandler);
shutdown_async_signal_handler();
}
*/
| 3,064 | 18.27673 | 56 |
cc
|
null |
ceph-main/src/test/simple_spin.cc
|
#include <future>
#include "gtest/gtest.h"
#include "include/spinlock.h"
using ceph::spin_lock;
using ceph::spin_unlock;
static std::atomic_flag lock = ATOMIC_FLAG_INIT;
static int64_t counter = 0;
TEST(SimpleSpin, Test0)
{
std::atomic_flag lock0 = ATOMIC_FLAG_INIT;
spin_lock(&lock0);
spin_unlock(&lock0);
}
static void* mythread(void *v)
{
for (int j = 0; j < 1000000; ++j) {
spin_lock(&lock);
counter++;
spin_unlock(&lock);
}
return NULL;
}
TEST(SimpleSpin, Test1)
{
counter = 0;
const auto n = 2000000U;
int ret;
pthread_t thread1;
pthread_t thread2;
ret = pthread_create(&thread1, NULL, mythread, NULL);
ASSERT_EQ(0, ret);
ret = pthread_create(&thread2, NULL, mythread, NULL);
ASSERT_EQ(0, ret);
ret = pthread_join(thread1, NULL);
ASSERT_EQ(0, ret);
ret = pthread_join(thread2, NULL);
ASSERT_EQ(0, ret);
ASSERT_EQ(n, counter);
// Should also work with pass-by-reference:
// (Note that we don't care about cross-threading here as-such.)
counter = 0;
auto f = async(std::launch::async, []() {
for(int i = 0; n != i; ++i) {
spin_lock(lock);
counter++;
spin_unlock(lock);
}
});
f.wait();
ASSERT_EQ(n, counter);
}
template <typename LockT>
int64_t check_lock_unlock(const int64_t n, int64_t& cntr, LockT& lock)
{
auto do_lock_unlock = [&]() -> int64_t {
int64_t i = 0;
for(; n != i; ++i) {
spin_lock(lock);
cntr++;
spin_unlock(lock);
}
return i;
};
auto fone = async(std::launch::async, do_lock_unlock);
auto ftwo = async(std::launch::async, do_lock_unlock);
auto fthree = async(std::launch::async, do_lock_unlock);
auto one = fone.get();
auto two = ftwo.get();
auto three = fthree.get();
// Google test doesn't like us using its macros out of individual tests, so:
if(n != one || n != two || n != three)
return 0;
return one + two + three;
}
TEST(SimpleSpin, Test2)
{
const auto n = 2000000U;
// ceph::spinlock:
{
counter = 0;
ceph::spinlock l;
ASSERT_EQ(0, counter);
auto result = check_lock_unlock(n, counter, l);
ASSERT_NE(0, counter);
ASSERT_EQ(counter, result);
}
}
// ceph::spinlock should work with std::lock_guard<>:
TEST(SimpleSpin, spinlock_guard)
{
const auto n = 2000000U;
ceph::spinlock sl;
counter = 0;
auto f = async(std::launch::async, [&sl]() {
for(int i = 0; n != i; ++i) {
std::lock_guard<ceph::spinlock> g(sl);
counter++;
}
});
auto g = async(std::launch::async, [&sl]() {
for(int i = 0; n != i; ++i) {
std::lock_guard<ceph::spinlock> g(sl);
counter++;
}
});
f.wait();
g.wait();
ASSERT_EQ(2*n, counter);
}
| 2,783 | 19.470588 | 77 |
cc
|
null |
ceph-main/src/test/smoke.sh
|
#!/usr/bin/env bash
source $CEPH_ROOT/qa/standalone/ceph-helpers.sh
mon_port=$(get_unused_port)
function run() {
local dir=$1
shift
export CEPH_MON="127.0.0.1:$mon_port"
export CEPH_ARGS
CEPH_ARGS+="--fsid=$(uuidgen) --auth-supported=none "
CEPH_ARGS+="--mon-host=$CEPH_MON "
set -e
local funcs=${@:-$(set | sed -n -e 's/^\(TEST_[0-9a-z_]*\) .*/\1/p')}
for func in $funcs ; do
setup $dir || return 1
$func $dir || return 1
teardown $dir || return 1
done
}
function TEST_minimal() {
local dir=$1
run_mon $dir a
run_mgr $dir x
run_osd $dir 0
run_osd $dir 1
run_osd $dir 2
create_rbd_pool
wait_for_clean
}
function TEST_multimon() {
local dir=$1
MONA="127.0.0.1:$((mon_port++))"
MONB="127.0.0.1:$((mon_port++))"
MONC="127.0.0.1:$((mon_port++))"
run_mon $dir a --public-addr $MONA
run_mon $dir b --public-addr $MONB
run_mon $dir c --public_addr $MONC
run_mgr $dir x
run_mgr $dir y
run_osd $dir 0
run_osd $dir 1
run_osd $dir 2
ceph osd pool create foo 32
ceph osd out 0
wait_for_clean
timeout 20 rados -p foo bench 4 write -b 4096 --no-cleanup || return 1
wait_for_clean
ceph osd in 0
flush_pg_stats
wait_for_clean
}
main smoke "$@"
| 1,310 | 19.169231 | 74 |
sh
|
null |
ceph-main/src/test/strtol.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 Dreamhost
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <cmath>
#include <string>
#include <map>
#include "common/strtol.h"
#include "gtest/gtest.h"
static void test_strict_strtoll(const char *str, long long expected, int base)
{
std::string err;
long long val = strict_strtoll(str, base, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
ASSERT_EQ(val, expected);
}
}
static void test_strict_strtol(const char *str, long expected)
{
std::string err;
long val = strict_strtol(str, 10, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
ASSERT_EQ(val, expected);
}
}
static void test_strict_strtod(const char *str, double expected)
{
std::string err;
double val = strict_strtod(str, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
// when comparing floats, use a margin of error
if ((expected - 0.001 > val) || (expected + 0.001 < val)) {
ASSERT_EQ(val, expected);
}
}
}
static void test_strict_strtof(const char *str, float expected)
{
std::string err;
float val = strict_strtof(str, &err);
if (!err.empty()) {
ASSERT_EQ(err, "");
}
else {
// when comparing floats, use a margin of error
if ((expected - 0.001 > val) || (expected + 0.001 < val)) {
ASSERT_EQ(val, expected);
}
}
}
TEST(StrToL, Simple1) {
test_strict_strtoll("123", 123, 10);
test_strict_strtoll("0", 0, 10);
test_strict_strtoll("-123", -123, 10);
test_strict_strtoll("8796093022208", 8796093022208LL, 10);
test_strict_strtoll("-8796093022208", -8796093022208LL, 10);
test_strict_strtoll("123", 123, 0);
test_strict_strtoll("0x7b", 123, 0);
test_strict_strtoll("4d2", 1234, 16);
test_strict_strtol("208", 208);
test_strict_strtol("-4", -4);
test_strict_strtol("0", 0);
test_strict_strtol("2147483646", 2147483646);
test_strict_strtof("0.05", 0.05);
test_strict_strtof("0", 0.0);
test_strict_strtof("-0", 0.0);
test_strict_strtof("10000000.5", 10000000.5);
test_strict_strtod("-0.2", -0.2);
test_strict_strtod("0.1", 0.1);
test_strict_strtod("0", 0.0);
}
static void test_strict_strtoll_err(const char *str)
{
std::string err;
strict_strtoll(str, 10, &err);
ASSERT_NE(err, "");
}
static void test_strict_strtol_err(const char *str)
{
std::string err;
strict_strtol(str, 10, &err);
ASSERT_NE(err, "");
}
static void test_strict_strtod_err(const char *str)
{
std::string err;
strict_strtod(str, &err);
ASSERT_NE(err, "");
}
static void test_strict_strtof_err(const char *str)
{
std::string err;
strict_strtof(str, &err);
ASSERT_NE(err, "");
}
TEST(StrToL, Error1) {
test_strict_strtoll_err("604462909807314587353088"); // overflow
test_strict_strtoll_err("aw shucks"); // invalid
test_strict_strtoll_err("343245 aw shucks"); // invalid chars at end
test_strict_strtoll_err("-"); // invalid
test_strict_strtol_err("35 aw shucks"); // invalid chars at end
test_strict_strtol_err("--0");
test_strict_strtol_err("-");
test_strict_strtod_err("345345.0-");
test_strict_strtod_err("34.0 garbo");
test_strict_strtof_err("0.05.0");
}
static void test_strict_iecstrtoll(const char *str)
{
std::string err;
strict_iecstrtoll(str, &err);
ASSERT_EQ(err, "");
}
static void test_strict_iecstrtoll_units(const std::string& foo,
std::string u, const int m)
{
std::string s(foo);
s.append(u);
const char *str = s.c_str();
std::string err;
uint64_t r = strict_iecstrtoll(str, &err);
ASSERT_EQ(err, "");
str = foo.c_str();
std::string err2;
long long tmp = strict_strtoll(str, 10, &err2);
ASSERT_EQ(err2, "");
tmp = (tmp << m);
ASSERT_EQ(tmp, (long long)r);
}
TEST(IECStrToLL, WithUnits) {
std::map<std::string,int> units;
units["B"] = 0;
units["K"] = 10;
units["M"] = 20;
units["G"] = 30;
units["T"] = 40;
units["P"] = 50;
units["E"] = 60;
units["Ki"] = 10;
units["Mi"] = 20;
units["Gi"] = 30;
units["Ti"] = 40;
units["Pi"] = 50;
units["Ei"] = 60;
for (std::map<std::string,int>::iterator p = units.begin();
p != units.end(); ++p) {
// the upper bound of uint64_t is 2^64 = 4E
test_strict_iecstrtoll_units("4", p->first, p->second);
test_strict_iecstrtoll_units("1", p->first, p->second);
test_strict_iecstrtoll_units("0", p->first, p->second);
}
}
TEST(IECStrToLL, WithoutUnits) {
test_strict_iecstrtoll("1024");
test_strict_iecstrtoll("1152921504606846976");
test_strict_iecstrtoll("0");
}
static void test_strict_iecstrtoll_err(const char *str)
{
std::string err;
strict_iecstrtoll(str, &err);
ASSERT_NE(err, "");
}
TEST(IECStrToLL, Error) {
test_strict_iecstrtoll_err("1024F");
test_strict_iecstrtoll_err("QDDSA");
test_strict_iecstrtoll_err("1b");
test_strict_iecstrtoll_err("100k");
test_strict_iecstrtoll_err("1000m");
test_strict_iecstrtoll_err("1g");
test_strict_iecstrtoll_err("20t");
test_strict_iecstrtoll_err("100p");
test_strict_iecstrtoll_err("1000e");
test_strict_iecstrtoll_err("B");
test_strict_iecstrtoll_err("M");
test_strict_iecstrtoll_err("BM");
test_strict_iecstrtoll_err("B0wef");
test_strict_iecstrtoll_err("0m");
test_strict_iecstrtoll_err("-1"); // it returns uint64_t
test_strict_iecstrtoll_err("-1K");
test_strict_iecstrtoll_err("1Bi");
test_strict_iecstrtoll_err("Bi");
test_strict_iecstrtoll_err("bi");
test_strict_iecstrtoll_err("gi");
test_strict_iecstrtoll_err("100ki");
test_strict_iecstrtoll_err("1000mi");
test_strict_iecstrtoll_err("1gi");
test_strict_iecstrtoll_err("20ti");
test_strict_iecstrtoll_err("100pi");
test_strict_iecstrtoll_err("1000ei");
// the upper bound of uint64_t is 2^64 = 4E, so 1024E overflows
test_strict_iecstrtoll_err("1024E"); // overflows after adding the suffix
}
// since strict_iecstrtoll is an alias of strict_iec_cast<uint64_t>(), quite a few
// of cases are covered by existing test cases of strict_iecstrtoll already.
TEST(StrictIECCast, Error) {
{
std::string err;
// the SI prefix is way too large for `int`.
(void)strict_iec_cast<int>("2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_iec_cast<int>("-2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_iec_cast<int>("1T", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_iec_cast<int64_t>("2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_iec_cast<int64_t>("-2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_iec_cast<int64_t>("1T", &err);
ASSERT_EQ(err, "");
}
}
static void test_strict_sistrtoll(const char *str)
{
std::string err;
strict_si_cast<uint64_t>(str, &err);
ASSERT_EQ(err, "");
}
static void test_strict_sistrtoll_units(const std::string& foo,
std::string u, const long long m)
{
std::string s(foo);
s.append(u);
const char *str = s.c_str();
std::string err;
uint64_t r = strict_si_cast<uint64_t>(str, &err);
ASSERT_EQ(err, "");
str = foo.c_str();
std::string err2;
long long tmp = strict_strtoll(str, 10, &err2);
ASSERT_EQ(err2, "");
tmp = (tmp * m);
ASSERT_EQ(tmp, (long long)r);
}
TEST(SIStrToLL, WithUnits) {
std::map<std::string,long long> units;
units["K"] = pow(10, 3);
units["M"] = pow(10, 6);
units["G"] = pow(10, 9);
units["T"] = pow(10, 12);
units["P"] = pow(10, 15);
units["E"] = pow(10, 18);
for (std::map<std::string,long long>::iterator p = units.begin();
p != units.end(); ++p) {
// the upper bound of uint64_t is 2^64 = 4E
test_strict_sistrtoll_units("4", p->first, p->second);
test_strict_sistrtoll_units("1", p->first, p->second);
test_strict_sistrtoll_units("0", p->first, p->second);
}
}
TEST(SIStrToLL, WithoutUnits) {
test_strict_sistrtoll("1024");
test_strict_sistrtoll("1152921504606846976");
test_strict_sistrtoll("0");
}
static void test_strict_sistrtoll_err(const char *str)
{
std::string err;
strict_si_cast<uint64_t>(str, &err);
ASSERT_NE(err, "");
}
TEST(SIStrToLL, Error) {
test_strict_sistrtoll_err("1024F");
test_strict_sistrtoll_err("QDDSA");
test_strict_sistrtoll_err("1b");
test_strict_sistrtoll_err("100k");
test_strict_sistrtoll_err("1000m");
test_strict_sistrtoll_err("1g");
test_strict_sistrtoll_err("20t");
test_strict_sistrtoll_err("100p");
test_strict_sistrtoll_err("1000e");
test_strict_sistrtoll_err("B");
test_strict_sistrtoll_err("M");
test_strict_sistrtoll_err("BM");
test_strict_sistrtoll_err("B0wef");
test_strict_sistrtoll_err("0m");
test_strict_sistrtoll_err("-1"); // it returns uint64_t
test_strict_sistrtoll_err("-1K");
test_strict_sistrtoll_err("1Bi");
test_strict_sistrtoll_err("Bi");
test_strict_sistrtoll_err("bi");
test_strict_sistrtoll_err("gi");
test_strict_sistrtoll_err("100ki");
test_strict_sistrtoll_err("1000mi");
test_strict_sistrtoll_err("1gi");
test_strict_sistrtoll_err("20ti");
test_strict_sistrtoll_err("100pi");
test_strict_sistrtoll_err("1000ei");
test_strict_sistrtoll_err("1B");
// the upper bound of uint64_t is 2^64 = 4E, so 1024E overflows
test_strict_sistrtoll_err("1024E"); // overflows after adding the suffix
}
// since strict_sistrtoll is an alias of strict_si_cast<uint64_t>(), quite a few
// of cases are covered by existing test cases of strict_sistrtoll already.
TEST(StrictSICast, Error) {
{
std::string err;
// the SI prefix is way too large for `int`.
(void)strict_si_cast<int>("2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_si_cast<int>("-2E", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_si_cast<int>("1T", &err);
ASSERT_NE(err, "");
}
{
std::string err;
(void)strict_si_cast<int64_t>("2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_si_cast<int64_t>("-2E", &err);
ASSERT_EQ(err, "");
}
{
std::string err;
(void)strict_si_cast<int64_t>("1T", &err);
ASSERT_EQ(err, "");
}
}
using ceph::parse;
using ceph::consume;
using namespace std::literals;
template<typename T>
inline void test_parse() {
auto r = parse<T>("23"sv);
ASSERT_TRUE(r);
EXPECT_EQ(*r, 23);
r = parse<T>(" 23"sv);
EXPECT_FALSE(r);
r = parse<T>("-5"sv);
if constexpr (std::is_signed_v<T>) {
ASSERT_TRUE(r);
EXPECT_EQ(*r, -5);
} else {
EXPECT_FALSE(r);
}
r = parse<T>("meow"sv);
EXPECT_FALSE(r);
r = parse<T>("9yards"sv);
EXPECT_FALSE(r);
}
TEST(Parse, Char) {
test_parse<char>();
}
TEST(Parse, UChar) {
test_parse<unsigned char>();
}
TEST(Parse, SChar) {
test_parse<signed char>();
}
TEST(Parse, UInt8) {
test_parse<std::uint8_t>();
}
TEST(Parse, Int8) {
test_parse<std::int8_t>();
}
TEST(Parse, UInt16) {
test_parse<std::uint16_t>();
}
TEST(Parse, Int16) {
test_parse<std::int16_t>();
}
TEST(Parse, UInt32) {
test_parse<std::uint32_t>();
}
TEST(Parse, Int32) {
test_parse<std::int32_t>();
}
TEST(Parse, UInt64) {
test_parse<std::uint64_t>();
}
TEST(Parse, Int64) {
test_parse<std::int64_t>();
}
TEST(Parse, UIntMax) {
test_parse<std::uintmax_t>();
}
TEST(Parse, IntMax) {
test_parse<std::intmax_t>();
}
TEST(Parse, UIntPtr) {
test_parse<std::uintptr_t>();
}
TEST(Parse, IntPtr) {
test_parse<std::intptr_t>();
}
TEST(Parse, UShort) {
test_parse<unsigned short>();
}
TEST(Parse, Short) {
test_parse<short>();
}
TEST(Parse, ULong) {
test_parse<unsigned long>();
}
TEST(Parse, Long) {
test_parse<long>();
}
TEST(Parse, ULongLong) {
test_parse<unsigned long long>();
}
TEST(Parse, LongLong) {
test_parse<long long>();
}
template<typename T>
inline void test_consume() {
auto pos = "23"sv;
auto spacepos = " 23"sv;
auto neg = "-5"sv;
auto meow = "meow"sv;
auto trail = "9yards"sv;
auto v = pos;
auto r = consume<T>(v);
ASSERT_TRUE(r);
EXPECT_EQ(*r, 23);
EXPECT_TRUE(v.empty());
v = spacepos;
r = consume<T>(v);
EXPECT_FALSE(r);
EXPECT_EQ(v, spacepos);
v = neg;
r = consume<T>(v);
if constexpr (std::is_signed_v<T>) {
ASSERT_TRUE(r);
EXPECT_EQ(*r, -5);
EXPECT_TRUE(v.empty());
} else {
EXPECT_FALSE(r);
EXPECT_EQ(v, neg);
}
v = meow;
r = consume<T>(v);
EXPECT_FALSE(r);
EXPECT_EQ(v, meow);
v = trail;
r = consume<T>(v);
ASSERT_TRUE(r);
EXPECT_EQ(*r, 9);
auto w = trail;
w.remove_prefix(1);
EXPECT_EQ(v, w);
}
TEST(Consume, Char) {
test_consume<char>();
}
TEST(Consume, UChar) {
test_consume<unsigned char>();
}
TEST(Consume, SChar) {
test_consume<signed char>();
}
TEST(Consume, UInt8) {
test_consume<std::uint8_t>();
}
TEST(Consume, Int8) {
test_consume<std::int8_t>();
}
TEST(Consume, UInt16) {
test_consume<std::uint16_t>();
}
TEST(Consume, Int16) {
test_consume<std::int16_t>();
}
TEST(Consume, UInt32) {
test_consume<std::uint32_t>();
}
TEST(Consume, Int32) {
test_consume<std::int32_t>();
}
TEST(Consume, UInt64) {
test_consume<std::uint64_t>();
}
TEST(Consume, Int64) {
test_consume<std::int64_t>();
}
TEST(Consume, UIntMax) {
test_consume<std::uintmax_t>();
}
TEST(Consume, IntMax) {
test_consume<std::intmax_t>();
}
TEST(Consume, UIntPtr) {
test_consume<std::uintptr_t>();
}
TEST(Consume, IntPtr) {
test_consume<std::intptr_t>();
}
TEST(Consume, UShort) {
test_consume<unsigned short>();
}
TEST(Consume, Short) {
test_consume<short>();
}
TEST(Consume, ULong) {
test_consume<unsigned long>();
}
TEST(Consume, Long) {
test_consume<long>();
}
TEST(Consume, ULongLong) {
test_consume<unsigned long long>();
}
TEST(Consume, LongLong) {
test_consume<long long>();
}
/*
* Local Variables:
* compile-command: "cd .. ; make unittest_strtol && ./unittest_strtol"
* End:
*/
| 14,177 | 20.812308 | 82 |
cc
|
null |
ceph-main/src/test/test_addrs.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* 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.
*
*/
#include "include/types.h"
#include "include/stringify.h"
#include "msg/msg_types.h"
#include "gtest/gtest.h"
#include <sstream>
using namespace std;
// input, parsed+printed addr output, leftover
// if the parse fails, output + leftover should both be blank.
const char *addr_checks[][3] = {
{ "127.0.0.1", "v2:127.0.0.1:0/0", "" },
{ "127.0.0.1 foo", "v2:127.0.0.1:0/0", " foo" },
{ "127.0.0.1:1234 foo", "v2:127.0.0.1:1234/0", " foo" },
{ "127.0.0.1:1234/5678 foo", "v2:127.0.0.1:1234/5678", " foo" },
{ "1.2.3:4 a", "", "1.2.3:4 a" },
{ "2607:f298:4:2243::5522", "v2:[2607:f298:4:2243::5522]:0/0", "" },
{ "[2607:f298:4:2243::5522]", "v2:[2607:f298:4:2243::5522]:0/0", "" },
{ "2607:f298:4:2243::5522a", "", "2607:f298:4:2243::5522a" },
{ "[2607:f298:4:2243::5522]a", "v2:[2607:f298:4:2243::5522]:0/0", "a" },
{ "[2607:f298:4:2243::5522]:1234a", "v2:[2607:f298:4:2243::5522]:1234/0", "a" },
{ "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "v2:[2001:db8:85a3::8a2e:370:7334]:0/0", "" },
{ "2001:2db8:85a3:4334:4324:8a2e:1370:7334", "v2:[2001:2db8:85a3:4334:4324:8a2e:1370:7334]:0/0", "" },
{ "::", "v2:[::]:0/0", "" },
{ "::zz", "v2:[::]:0/0", "zz" },
{ ":: 12:34", "v2:[::]:0/0", " 12:34" },
{ "-", "-", "" },
{ "-asdf", "-", "asdf" },
{ "v1:1.2.3.4", "v1:1.2.3.4:0/0", "" },
{ "v1:1.2.3.4:12", "v1:1.2.3.4:12/0", "" },
{ "v1:1.2.3.4:12/34", "v1:1.2.3.4:12/34", "" },
{ "v2:1.2.3.4", "v2:1.2.3.4:0/0", "" },
{ "v2:1.2.3.4:12", "v2:1.2.3.4:12/0", "" },
{ "v2:1.2.3.4:12/34", "v2:1.2.3.4:12/34", "" },
{ NULL, NULL, NULL },
};
const char *addr_only_checks[][3] = {
// we shouldn't parse an addrvec...
{ "[v2:1.2.3.4:111/0,v1:5.6.7.8:222/0]", "", "[v2:1.2.3.4:111/0,v1:5.6.7.8:222/0]" },
{ NULL, NULL, NULL },
};
TEST(Msgr, TestAddrParsing)
{
for (auto& addr_checks : { addr_checks, addr_only_checks }) {
for (unsigned i = 0; addr_checks[i][0]; ++i) {
entity_addr_t a;
const char *end = "";
bool ok = a.parse(addr_checks[i][0], &end);
string out;
if (ok) {
stringstream ss;
ss << a;
getline(ss, out);
}
string left = end;
cout << "'" << addr_checks[i][0] << "' -> '" << out << "' + '" << left << "'" << std::endl;
ASSERT_EQ(out, addr_checks[i][1]);
ASSERT_EQ(left, addr_checks[i][2]);
if (addr_checks[i][0] == end) {
ASSERT_FALSE(ok);
} else {
ASSERT_TRUE(ok);
}
}
}
}
// check that legacy encoding to new decoding behaves
const char *addr_checks2[][3] = {
{ "v1:127.0.0.1", "v1:127.0.0.1:0/0", "" },
{ "v1:127.0.0.1 foo", "v1:127.0.0.1:0/0", " foo" },
{ "v1:127.0.0.1:1234 foo", "v1:127.0.0.1:1234/0", " foo" },
{ "v1:127.0.0.1:1234/5678 foo", "v1:127.0.0.1:1234/5678", " foo" },
{ "v1:2607:f298:4:2243::5522", "v1:[2607:f298:4:2243::5522]:0/0", "" },
{ "v1:[2607:f298:4:2243::5522]", "v1:[2607:f298:4:2243::5522]:0/0", "" },
{ "v1:[2607:f298:4:2243::5522]a", "v1:[2607:f298:4:2243::5522]:0/0", "a" },
{ "v1:[2607:f298:4:2243::5522]:1234a", "v1:[2607:f298:4:2243::5522]:1234/0", "a" },
{ "v1:2001:0db8:85a3:0000:0000:8a2e:0370:7334", "v1:[2001:db8:85a3::8a2e:370:7334]:0/0", "" },
{ "v1:2001:2db8:85a3:4334:4324:8a2e:1370:7334", "v1:[2001:2db8:85a3:4334:4324:8a2e:1370:7334]:0/0", "" },
{ "v1:1.2.3.4", "v1:1.2.3.4:0/0", "" },
{ "v1:1.2.3.4:12", "v1:1.2.3.4:12/0", "" },
{ "v1:1.2.3.4:12/34", "v1:1.2.3.4:12/34", "" },
{ NULL, NULL, NULL },
};
TEST(Msgr, TestAddrEncodeAddrvecDecode)
{
for (unsigned i = 0; addr_checks2[i][0]; ++i) {
entity_addr_t addr;
entity_addrvec_t addrvec;
const char *end = "";
bool ok = addr.parse(addr_checks2[i][0], &end);
ASSERT_TRUE(ok);
bufferlist bl;
addr.encode(bl, 0);
auto bli = bl.cbegin();
addrvec.decode(bli);
cout << addr_checks2[i][0] << " " << addr << " " << addrvec << std::endl;
ASSERT_EQ(addr, addrvec.v[0]);
if (addr_checks2[i][0] == end) {
ASSERT_FALSE(ok);
} else {
ASSERT_TRUE(ok);
}
}
}
TEST(Msgr, TestAddrvec0EncodeAddrDecode)
{
for (unsigned i = 0; addr_checks2[i][0]; ++i) {
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
const char *end = "";
bool ok = addr.parse(addr_checks2[i][0], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
entity_addr_t a;
a.decode(bli);
ASSERT_EQ(addr, a);
}
}
TEST(Msgr, TestEmptyAddrvecEncodeAddrDecode)
{
entity_addrvec_t addrvec;
entity_addr_t addr;
bufferlist bl;
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, entity_addr_t());
}
const char *addrvec_checks[][4] = {
{ "v1:1.2.3.4", "v2:1.2.3.4", "v1:1.2.3.4", "v2:1.2.3.4" },
{ "v2:1.2.3.5", "v1:1.2.3.5", "v1:1.2.3.5", "v2:1.2.3.5" },
{ "v2:1.2.3.6", "v2:1.2.3.6", "v1:1.2.3.6", "v2:1.2.3.6" },
{ "v2:1.2.3.7", "v1:1.2.3.7", "v1:1.2.3.7", "v2:1.2.3.7" },
{ NULL, NULL, NULL, NULL },
};
/*
* multiple addrs where one is legacy and others are not
* legacy addr is in position 0
*/
TEST(Msgr, TestAddrvecEncodeAddrDecode0)
{
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
for (unsigned i = 0; addrvec_checks[i][0]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][0], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, addrvec.v[0]);
}
/*
* multiple addrs where one is legacy and others are not
* legacy addr is not in position 0
*/
TEST(Msgr, TestAddrvecEncodeAddrDecode1)
{
entity_addr_t addr, a;
entity_addrvec_t addrvec;
bufferlist bl;
bool flag = true;
for (unsigned i = 0; addrvec_checks[i][1]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][1], &end);
ASSERT_TRUE(ok);
if (addr.type == entity_addr_t::TYPE_LEGACY && flag) {
a = addr;
flag = !flag;
}
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, a);
}
/* multiple legacy addrs */
TEST(Msgr, TestAddrvecEncodeAddrDecode2)
{
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
for (unsigned i = 0; addrvec_checks[i][2]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][2], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, addrvec.v[0]);
}
/* all non-legacy addrs */
TEST(Msgr, TestAddrvecEncodeAddrDecode3)
{
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
for (unsigned i = 0; addrvec_checks[i][3]; ++i) {
const char *end = "";
bool ok = addr.parse(addrvec_checks[i][3], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
}
addrvec.encode(bl, 0);
auto bli = bl.cbegin();
addr.decode(bli);
//cout << addrvec << " (legacy " << addrvec.legacy_addr()
//<< ") -> " << addr << std::endl;
ASSERT_NE(addr, addrvec.v[0]); // it's not the first addr(which is non-legacy)
ASSERT_EQ(addr, entity_addr_t()); // it's not a blank addr either
}
const char *addrvec_parse_checks[][3] = {
{ "", "", "" },
{ "foo", "", "foo" },
{ " foo", "", " foo" },
{ "127.0.0.1", "v2:127.0.0.1:0/0", "" },
{ "127.0.0.1 foo", "v2:127.0.0.1:0/0", " foo" },
{ "[127.0.0.1]", "v2:127.0.0.1:0/0", "" },
{ "[127.0.0.1] foo", "v2:127.0.0.1:0/0", " foo" },
{ "127.0.0.1,::,- foo", "v2:127.0.0.1:0/0", ",::,- foo" },
{ "[127.0.0.1,::,-] foo", "[v2:127.0.0.1:0/0,v2:[::]:0/0,-]", " foo" },
{ "[127.0.0.1,::],- foo", "[v2:127.0.0.1:0/0,v2:[::]:0/0]", ",- foo" },
{ "[1.2.3.4,::,foo]", "", "[1.2.3.4,::,foo]" },
{ "[1.2.3.4,::,- foo", "", "[1.2.3.4,::,- foo" },
{ "[[::],1.2.3.4]", "[v2:[::]:0/0,v2:1.2.3.4:0/0]", "" },
{ "[::],1.2.3.4", "v2:[::]:0/0", ",1.2.3.4" },
{ NULL, NULL, NULL },
};
TEST(entity_addrvec_t, parse)
{
entity_addrvec_t addrvec;
for (auto v : { addr_checks, addr_checks2, addrvec_parse_checks }) {
for (unsigned i = 0; v[i][0]; ++i) {
const char *end = "";
bool ret = addrvec.parse(v[i][0], &end);
string out = stringify(addrvec);
string left = end;
cout << "'" << v[i][0] << "' -> '" << out << "' + '" << left << "'"
<< std::endl;
ASSERT_EQ(out, v[i][1]);
ASSERT_EQ(left, v[i][2]);
ASSERT_TRUE(out.empty() || ret);
}
}
}
TEST(entity_addrvec_t, legacy_equals)
{
entity_addr_t a1, a2;
ASSERT_TRUE(a1.parse("v1:1.2.3.4:567/890"));
ASSERT_TRUE(a2.parse("v2:1.2.3.4:567/890"));
entity_addrvec_t av1(a1);
entity_addrvec_t av21;
av21.v.push_back(a2);
av21.v.push_back(a1);
ASSERT_TRUE(av1.legacy_equals(av1));
ASSERT_TRUE(av21.legacy_equals(av21));
ASSERT_TRUE(av1.legacy_equals(av21));
ASSERT_TRUE(av21.legacy_equals(av1));
entity_addr_t b1, b2;
ASSERT_TRUE(b1.parse("v1:1.2.3.5:567/8"));
ASSERT_TRUE(b2.parse("v2:1.2.3.5:567/8"));
entity_addrvec_t bv1(b1);
entity_addrvec_t bv21;
bv21.v.push_back(b2);
bv21.v.push_back(b1);
ASSERT_TRUE(bv1.legacy_equals(bv21));
ASSERT_TRUE(bv21.legacy_equals(bv1));
ASSERT_FALSE(av1.legacy_equals(bv1));
ASSERT_FALSE(av21.legacy_equals(bv21));
ASSERT_FALSE(av21.legacy_equals(bv1));
ASSERT_FALSE(av1.legacy_equals(bv21));
}
| 9,731 | 28.050746 | 107 |
cc
|
null |
ceph-main/src/test/test_admin_socket_output.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2017 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include <algorithm> // for move
#include <iostream> // for ostream
#include <memory> // for unique_ptr
#include <string> // for operator<<
#include <vector> // for vector
#include <boost/program_options/option.hpp> // for program_opt...
#include <boost/program_options/options_description.hpp> // for options_des...
#include <boost/program_options/parsers.hpp> // for basic_comma...
#include <boost/program_options/variables_map.hpp> // for variables_map
#include <boost/program_options/parsers.hpp> // for basic_comma...
#include "admin_socket_output.h"
#include "admin_socket_output_tests.h"
namespace po = boost::program_options;
void usage(po::options_description desc) {
std::cout << desc << std::endl;
}
void handle_unrecognised(std::vector<std::string>&& unrecognised) {
for (auto& un : unrecognised) {
std::cout << "Unrecognized Parameter: " << un << std::endl;
}
}
// Test functions:
// See admin_socket_output_tests.h
int main(int argc, char** argv) {
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("all", "implies"
" --osd"
" --mon"
" --mgr"
" --mds"
" --client"
" --vstart")
("osd", "Test osd admin socket output")
("mon", "Test mon admin socket output")
("mgr", "Test mgr admin socket output")
("mds", "Test mds admin socket output")
("client", "Test client (includes rgw) admin socket output")
("vstart", po::value<std::string>()->implicit_value("./out"),
"Modify to run in vstart environment")
;
auto parsed =
po::command_line_parser(argc, argv).options(desc).allow_unregistered().run();
po::variables_map vm;
po::store(parsed, vm);
po::notify(vm);
auto unrecognised = collect_unrecognized(parsed.options, po::include_positional);
if(!unrecognised.empty()) {
handle_unrecognised(std::move(unrecognised));
usage(desc);
return 1;
}
if (vm.count("help") || vm.empty()) {
usage(desc);
return 2;
}
std::unique_ptr<AdminSocketOutput> asockout(new AdminSocketOutput);
if (vm.count("vstart")) {
asockout->mod_for_vstart(vm["vstart"].as<std::string>());
}
if(vm.count("all")) {
asockout->add_target("all");
} else {
if (vm.count("osd")) {
asockout->add_target("osd");
}
if (vm.count("mon")) {
asockout->add_target("mon");
}
if (vm.count("mgr")) {
asockout->add_target("mgr");
}
if (vm.count("mds")) {
asockout->add_target("mds");
}
if (vm.count("client")) {
asockout->add_target("client");
}
}
// Postpone commands that may affect later commands
asockout->postpone("mds", "force_readonly");
// Custom commands
//Example:
//asockout->add_command("osd", R"({"prefix":"config get", "var":"admin_socket"})");
// End custom commands
// Tests
//Example:
//asockout->add_test("osd", R"({"prefix":"config get", "var":"admin_socket"})", test_config_get_admin_socket);
asockout->add_test("osd", R"({"prefix":"dump_pgstate_history"})", test_dump_pgstate_history);
// End tests
asockout->exec();
return 0;
}
| 3,766 | 27.976923 | 112 |
cc
|
null |
ceph-main/src/test/test_any.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2018 Adam C. Emerson <[email protected]>
*
* 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.
*
*/
#include <initializer_list>
#include <optional>
#include "gtest/gtest.h"
#include "include/any.h"
using std::optional;
using std::bad_any_cast;
using ceph::immobile_any;
using ceph::unique_any;
using ceph::shared_any;
using ceph::make_immobile_any;
using ceph::make_unique_any;
using ceph::make_shared_any;
using ceph::any_cast;
using std::swap;
template<typename A>
static void test_empty() {
A a;
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
a.reset();
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
}
TEST(Empty, Immobile) {
static_assert(std::is_nothrow_default_constructible_v<immobile_any<1024>>);
test_empty<immobile_any<1024>>();
}
TEST(Empty, Unique) {
static_assert(std::is_nothrow_default_constructible_v<unique_any>);
test_empty<unique_any>();
}
TEST(Empty, Shared) {
static_assert(std::is_nothrow_default_constructible_v<shared_any>);
test_empty<shared_any>();
}
struct cmd_tattler {
static thread_local bool copied;
static thread_local bool moved;
static thread_local bool destructed;
static void reset() {
copied = false;
moved = false;
destructed = false;
}
cmd_tattler() noexcept = default;
~cmd_tattler() noexcept {
if (destructed) {
std::terminate();
}
destructed = true;
}
cmd_tattler(const cmd_tattler&) noexcept {
if (copied) {
std::terminate();
}
copied = true;
}
cmd_tattler& operator =(const cmd_tattler&) noexcept {
if (copied) {
std::terminate();
}
copied = true;
return *this;
}
cmd_tattler(cmd_tattler&&) noexcept {
if (moved) {
std::terminate();
}
moved = true;
}
cmd_tattler& operator =(cmd_tattler&&) noexcept {
if (moved) {
std::terminate();
}
moved = true;
return *this;
}
};
thread_local bool cmd_tattler::copied = false;
thread_local bool cmd_tattler::moved = false;
thread_local bool cmd_tattler::destructed = false;
struct not_noexcept {
not_noexcept() = default;
not_noexcept(const not_noexcept&) noexcept(false) {
}
not_noexcept& operator =(const not_noexcept&) noexcept(false) {
return *this;
}
not_noexcept(not_noexcept&&) noexcept(false) {
}
not_noexcept& operator =(not_noexcept&&) noexcept(false) {
return *this;
}
template<typename ...Args>
explicit not_noexcept(Args&& ...) noexcept(false) {
}
template<typename U, typename ...Args>
not_noexcept(std::initializer_list<U>, Args&& ...) noexcept(false) {
}
};
template<typename A>
static void test_value_CMD() {
{
cmd_tattler::reset();
cmd_tattler c;
A a(c);
EXPECT_TRUE(cmd_tattler::copied);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
cmd_tattler::reset();
a = c;
EXPECT_TRUE(cmd_tattler::copied);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a = c;
EXPECT_TRUE(cmd_tattler::copied);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
cmd_tattler::reset();
}
{
cmd_tattler::reset();
cmd_tattler c;
A a(std::move(c));
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
cmd_tattler::reset();
a = std::move(c);
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a = std::move(c);
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
cmd_tattler::reset();
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
cmd_tattler::reset();
a = cmd_tattler{};
EXPECT_TRUE(cmd_tattler::moved);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(cmd_tattler), a.type());
cmd_tattler::reset();
a.reset();
EXPECT_TRUE(cmd_tattler::destructed);
cmd_tattler::reset();
}
}
TEST(Value_CMD, Immobile) {
static_assert(std::is_nothrow_constructible_v<
immobile_any<1024>, const cmd_tattler&>);
static_assert(std::is_nothrow_assignable_v<
immobile_any<1024>, const cmd_tattler&>);
static_assert(std::is_nothrow_constructible_v<
immobile_any<1024>, cmd_tattler&&>);
static_assert(std::is_nothrow_assignable_v<
immobile_any<1024>, cmd_tattler&&>);
static_assert(!std::is_nothrow_constructible_v<
immobile_any<1024>, const not_noexcept&>);
static_assert(!std::is_nothrow_assignable_v<
immobile_any<1024>, const not_noexcept&>);
static_assert(!std::is_nothrow_constructible_v<
immobile_any<1024>, not_noexcept&&>);
static_assert(!std::is_nothrow_assignable_v<
immobile_any<1024>, not_noexcept&&>);
test_value_CMD<immobile_any<1024>>();
}
TEST(Value_CMD, Unique) {
static_assert(!std::is_nothrow_constructible_v<
unique_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_constructible_v<
unique_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_constructible_v<
unique_any, const not_noexcept&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, const not_noexcept&>);
static_assert(!std::is_nothrow_constructible_v<
unique_any, not_noexcept&&>);
static_assert(!std::is_nothrow_assignable_v<
unique_any, not_noexcept&&>);
test_value_CMD<unique_any>();
}
TEST(Value_CMD, Shared) {
static_assert(!std::is_nothrow_constructible_v<
shared_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, const cmd_tattler&>);
static_assert(!std::is_nothrow_constructible_v<
shared_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, cmd_tattler&&>);
static_assert(!std::is_nothrow_constructible_v<
shared_any, const not_noexcept&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, const not_noexcept&>);
static_assert(!std::is_nothrow_constructible_v<
shared_any, not_noexcept&&>);
static_assert(!std::is_nothrow_assignable_v<
shared_any, not_noexcept&&>);
test_value_CMD<shared_any>();
}
template<typename A>
static void test_move() {
{
A a(5);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
A b(std::move(a));
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_FALSE(a.has_value());
EXPECT_EQ(typeid(void), a.type());
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
A b(5);
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
cmd_tattler::reset();
a = std::move(b);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_FALSE(b.has_value());
EXPECT_EQ(typeid(void), b.type());
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
}
}
static_assert(!std::is_move_constructible_v<immobile_any<1024>>);
static_assert(!std::is_move_assignable_v<immobile_any<1024>>);
TEST(Move, Unique) {
static_assert(std::is_nothrow_move_constructible_v<unique_any>);
static_assert(std::is_nothrow_move_assignable_v<unique_any>);
test_move<unique_any>();
}
TEST(Move, Shared) {
static_assert(std::is_nothrow_move_constructible_v<shared_any>);
static_assert(std::is_nothrow_move_assignable_v<shared_any>);
test_move<shared_any>();
}
template<typename A>
static void test_copy() {
{
const A a(5);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
A b(a);
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
EXPECT_EQ(any_cast<int>(a), any_cast<int>(b));
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
const A b(5);
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
cmd_tattler::reset();
a = b;
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_EQ(any_cast<int>(a), any_cast<int>(b));
}
}
static_assert(!std::is_copy_constructible_v<immobile_any<1024>>);
static_assert(!std::is_copy_assignable_v<immobile_any<1024>>);
static_assert(!std::is_copy_constructible_v<unique_any>);
static_assert(!std::is_copy_assignable_v<unique_any>);
TEST(Copy, Shared) {
static_assert(std::is_nothrow_copy_constructible_v<shared_any>);
test_copy<shared_any>();
}
struct unmoving {
optional<int> a;
unmoving() noexcept {}
template<typename... Args>
explicit unmoving(Args&& ...args) noexcept
: a(sizeof...(Args)) {}
template<typename U, typename... Args>
explicit unmoving(std::initializer_list<U> l) noexcept
: a(-l.size()) {}
template<typename U, typename... Args>
unmoving(std::initializer_list<U> l, Args&& ...args) noexcept
: a(-l.size() * sizeof...(Args)) {}
unmoving(const unmoving&) = delete;
unmoving& operator =(const unmoving&) = delete;
unmoving(unmoving&&) = delete;
unmoving& operator =(unmoving&&) = delete;
};
template<typename A>
static void test_unmoving_pack_il() {
// Nothing!
{
const A a(std::in_place_type<unmoving>);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>();
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<unmoving&>(a).a);
}
// Pack!
{
const A a(std::in_place_type<unmoving>, nullptr, 5, 3.1);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>(nullptr, 5, 3.1);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_EQ(3, *any_cast<unmoving&>(a).a);
}
// List!
{
const A a(std::in_place_type<unmoving>, {true, true, true, true});
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>({true, true, true, true});
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_EQ(-4, *any_cast<unmoving&>(a).a);
}
// List + pack!!
{
const A a(std::in_place_type<unmoving>, {true, true, true, true},
nullptr, 5, 3.1);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
a.template emplace<unmoving>({true, true, true, true}, nullptr, 5, 3.1);
EXPECT_TRUE(cmd_tattler::destructed);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_EQ(-12, *any_cast<unmoving&>(a).a);
}
}
TEST(UmovingPackIl, Immobile) {
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>()));
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>, std::nullptr_t, int, double>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>(
nullptr, 5, 3.1)));
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>, std::initializer_list<int>>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>(
{true, true, true, true})));
static_assert(std::is_nothrow_constructible_v<immobile_any<1024>,
std::in_place_type_t<unmoving>, std::initializer_list<int>,
std::nullptr_t, int, double>);
static_assert(noexcept(immobile_any<1024>{}.emplace<unmoving>(
{true, true, true, true}, nullptr, 5, 3.1)));
test_unmoving_pack_il<immobile_any<1024>>();
}
TEST(UmovingPackIl, Unique) {
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>()));
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>, std::nullptr_t, int, double>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>(
nullptr, 5, 3.1)));
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>(
{true, true, true, true})));
static_assert(!std::is_nothrow_constructible_v<unique_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>,
std::nullptr_t, int, double>);
static_assert(!noexcept(unique_any{}.emplace<unmoving>(
{true, true, true, true}, nullptr, 5, 3.1)));
test_unmoving_pack_il<unique_any>();
}
TEST(UmovingPackIl, Shared) {
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>()));
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>, std::nullptr_t, int, double>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>(
nullptr, 5, 3.1)));
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>(
{true, true, true, true})));
static_assert(!std::is_nothrow_constructible_v<shared_any,
std::in_place_type_t<unmoving>, std::initializer_list<int>,
std::nullptr_t, int, double>);
static_assert(!noexcept(shared_any{}.emplace<unmoving>(
{true, true, true, true}, nullptr, 5, 3.1)));
test_unmoving_pack_il<shared_any>();
}
template<typename A>
static void test_swap() {
A a(true);
ASSERT_TRUE(a.has_value());
ASSERT_EQ(typeid(bool), a.type());
ASSERT_EQ(true, any_cast<bool>(a));
A b(5);
ASSERT_TRUE(b.has_value());
ASSERT_EQ(typeid(int), b.type());
ASSERT_EQ(5, any_cast<int>(b));
a.swap(b);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(int), a.type());
EXPECT_EQ(5, any_cast<int>(a));
EXPECT_TRUE(b.has_value());
ASSERT_EQ(typeid(bool), b.type());
ASSERT_EQ(true, any_cast<bool>(b));
swap(a,b);
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(bool), a.type());
EXPECT_EQ(true, any_cast<bool>(a));
EXPECT_TRUE(b.has_value());
EXPECT_EQ(typeid(int), b.type());
EXPECT_EQ(5, any_cast<int>(b));
}
static_assert(!std::is_swappable_v<immobile_any<1024>>);
TEST(Swap, Unique) {
static_assert(std::is_nothrow_swappable_v<unique_any>);
test_swap<unique_any>();
}
TEST(Swap, Shared) {
static_assert(std::is_nothrow_swappable_v<shared_any>);
test_swap<shared_any>();
}
template<typename A>
static void test_cast() {
// Empty
{
A a;
EXPECT_EQ(nullptr, any_cast<int>(&a));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_THROW({any_cast<int&>(a);}, bad_any_cast);
EXPECT_THROW({any_cast<int>(std::move(a));}, bad_any_cast);
EXPECT_THROW({any_cast<int&&>(std::move(a));}, bad_any_cast);
}
// Constant Empty
{
const A a{};
EXPECT_EQ(nullptr, any_cast<int>(const_cast<const A*>(&a)));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_THROW({any_cast<const int&>(a);}, bad_any_cast);
}
// Filled!
{
A a(true);
EXPECT_TRUE(*any_cast<bool>(&a));
EXPECT_EQ(nullptr, any_cast<int>(&a));
EXPECT_TRUE(any_cast<bool>(a));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_TRUE(any_cast<bool&>(a));
EXPECT_THROW({any_cast<int&>(a);}, bad_any_cast);
EXPECT_TRUE(any_cast<bool>(std::move(a)));
EXPECT_THROW({any_cast<int>(std::move(a));}, bad_any_cast);
EXPECT_TRUE(any_cast<bool&&>(std::move(a)));
EXPECT_THROW({any_cast<int&&>(std::move(a));}, bad_any_cast);
}
// Constant filled
{
const A a(true);
EXPECT_TRUE(*any_cast<const bool>(&a));
EXPECT_EQ(nullptr, any_cast<const int>(&a));
EXPECT_TRUE(any_cast<bool>(a));
EXPECT_THROW({any_cast<int>(a);}, bad_any_cast);
EXPECT_TRUE(any_cast<const bool&>(a));
EXPECT_THROW({any_cast<const int&>(a);}, bad_any_cast);
}
// Move!
{
cmd_tattler::reset();
A a(cmd_tattler{});
cmd_tattler::reset();
auto q = any_cast<cmd_tattler>(std::move(a));
EXPECT_TRUE(cmd_tattler::moved);
cmd_tattler::reset();
a.reset();
cmd_tattler::reset();
}
// Move! Again!
{
cmd_tattler::reset();
auto q = any_cast<cmd_tattler>(A(std::in_place_type<cmd_tattler>));
EXPECT_TRUE(cmd_tattler::moved);
cmd_tattler::reset();
}
}
TEST(Cast, Immobile) {
test_cast<immobile_any<1024>>();
}
TEST(Cast, Unique) {
test_cast<unique_any>();
}
TEST(Cast, Shared) {
test_cast<shared_any>();
}
TEST(Make, Immobile) {
// Nothing!
{
auto a{make_immobile_any<unmoving, 1024>()};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
// Pack!
{
auto a(make_immobile_any<unmoving, 1024>(nullptr, 5, 3.1));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
// List!
{
auto a(make_immobile_any<unmoving, 1024>({true, true, true, true}));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
// List + pack!!
{
auto a{make_immobile_any<unmoving, 1024>({true, true, true, true},
nullptr, 5, 3.1)};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
}
TEST(Make, Unique) {
// Nothing!
{
auto a{make_unique_any<unmoving>()};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
// Pack!
{
auto a(make_unique_any<unmoving>(nullptr, 5, 3.1));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
// List!
{
auto a(make_unique_any<unmoving>({true, true, true, true}));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
// List + pack!!
{
auto a{make_unique_any<unmoving>({true, true, true, true},
nullptr, 5, 3.1)};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
}
TEST(Make, Shared) {
// Nothing!
{
auto a{make_shared_any<unmoving>()};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_FALSE(any_cast<const unmoving&>(a).a);
}
// Pack!
{
auto a(make_shared_any<unmoving>(nullptr, 5, 3.1));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(3, *any_cast<const unmoving&>(a).a);
}
// List!
{
auto a(make_shared_any<unmoving>({true, true, true, true}));
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-4, *any_cast<const unmoving&>(a).a);
}
// List + pack!!
{
auto a{make_shared_any<unmoving>({true, true, true, true},
nullptr, 5, 3.1)};
EXPECT_TRUE(a.has_value());
EXPECT_EQ(typeid(unmoving), a.type());
EXPECT_TRUE(any_cast<const unmoving&>(a).a);
EXPECT_EQ(-12, *any_cast<const unmoving&>(a).a);
}
}
| 21,692 | 25.682657 | 77 |
cc
|
null |
ceph-main/src/test/test_arch.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2014 Red Hat <[email protected]>
*
* Author: Loic Dachary <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include "arch/probe.h"
#include "arch/intel.h"
#include "arch/arm.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#define FLAGS_SIZE 4096
TEST(Arch, all)
{
ceph_arch_probe();
EXPECT_TRUE(ceph_arch_probed);
#if (__arm__ || __aarch64__ || __x86_64__) && __linux__
char flags[FLAGS_SIZE];
FILE *f = popen("grep '^\\(flags\\|Features\\)[ ]*:' "
"/proc/cpuinfo | head -1", "r");
if(f == NULL || fgets(flags, FLAGS_SIZE - 1, f) == NULL) {
// silently do nothing if /proc/cpuinfo does exist, is not
// readable or does not contain the expected information
if (f)
pclose(f);
return;
}
pclose(f);
flags[strlen(flags) - 1] = ' ';
int expected;
#if (__arm__ || __aarch64__)
expected = (strstr(flags, " neon ") || strstr(flags, " asimd ")) ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_neon);
#endif
#if (__aarch64__)
expected = strstr(flags, " crc32 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_aarch64_crc32);
#endif
#if (__x86_64__)
expected = strstr(flags, " pclmulqdq ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_pclmul);
expected = strstr(flags, " sse4_2 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse42);
expected = strstr(flags, " sse4_1 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse41);
expected = (strstr(flags, " sse3 ") || strstr(flags, " ssse3 ") || strstr(flags, " pni ")) ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse3);
expected = strstr(flags, " ssse3 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_ssse3);
expected = strstr(flags, " sse2 ") ? 1 : 0;
EXPECT_EQ(expected, ceph_arch_intel_sse2);
#endif
#endif
}
/*
* Local Variables:
* compile-command: "cd .. ; make -j4 &&
* make unittest_arch &&
* valgrind --tool=memcheck ./unittest_arch --gtest_filter=*.*"
* End:
*/
| 2,353 | 24.042553 | 101 |
cc
|
null |
ceph-main/src/test/test_auth.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "include/types.h"
#include "include/stringify.h"
#include "auth/Auth.h"
#include "gtest/gtest.h"
#include "common/ceph_context.h"
#include "global/global_context.h"
#include "auth/AuthRegistry.h"
#include <sstream>
TEST(AuthRegistry, con_modes)
{
auto cct = g_ceph_context;
AuthRegistry reg(cct);
std::vector<uint32_t> modes;
const std::vector<uint32_t> crc_secure = { CEPH_CON_MODE_CRC,
CEPH_CON_MODE_SECURE };
const std::vector<uint32_t> secure_crc = { CEPH_CON_MODE_SECURE,
CEPH_CON_MODE_CRC };
const std::vector<uint32_t> secure = { CEPH_CON_MODE_SECURE };
cct->_conf.set_val(
"enable_experimental_unrecoverable_data_corrupting_features", "*");
// baseline: everybody agrees
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
cct->_conf.set_val("ms_cluster_mode", "crc secure");
cct->_conf.set_val("ms_service_mode", "crc secure");
cct->_conf.set_val("ms_client_mode", "crc secure");
cct->_conf.set_val("ms_mon_cluster_mode", "crc secure");
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.set_val("ms_mon_client_mode", "crc secure");
cct->_conf.apply_changes(NULL);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
ASSERT_EQ((uint32_t)CEPH_CON_MODE_CRC, reg.pick_mode(CEPH_ENTITY_TYPE_OSD,
CEPH_AUTH_CEPHX,
crc_secure));
// what mons prefer secure, internal to mon cluster only
cct->_conf.set_val("ms_mon_cluster_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
/* mon/mgr are treated the same, and relevant config is ms_mon_cluster_mode */
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how all cluster -> mon connections secure?
cct->_conf.set_val("ms_mon_service_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how about client -> mon connections?
cct->_conf.set_val("ms_mon_client_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// ms_mon)client_mode doesn't does't affect daemons, though...
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how about all internal cluster connection secure?
cct->_conf.set_val("ms_cluster_mode", "secure");
cct->_conf.set_val("ms_mon_service_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MGR);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MDS);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MON);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// how about all connections to the cluster?
cct->_conf.set_val("ms_service_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, crc_secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_OSD);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MGR);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
cct->_set_module_type(CEPH_ENTITY_TYPE_MDS);
reg.get_supported_modes(CEPH_ENTITY_TYPE_CLIENT, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// client forcing things?
cct->_conf.set_val("ms_cluster_mode", "crc secure");
cct->_conf.set_val("ms_service_mode", "crc secure");
cct->_conf.set_val("ms_client_mode", "secure");
cct->_conf.set_val("ms_mon_cluster_mode", "crc secure");
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.set_val("ms_mon_client_mode", "secure");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure);
// client *preferring* secure?
cct->_conf.set_val("ms_cluster_mode", "crc secure");
cct->_conf.set_val("ms_service_mode", "crc secure");
cct->_conf.set_val("ms_client_mode", "secure crc");
cct->_conf.set_val("ms_mon_cluster_mode", "crc secure");
cct->_conf.set_val("ms_mon_service_mode", "crc secure");
cct->_conf.set_val("ms_mon_client_mode", "secure crc");
cct->_conf.apply_changes(NULL);
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MON, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MGR, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
reg.get_supported_modes(CEPH_ENTITY_TYPE_OSD, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
reg.get_supported_modes(CEPH_ENTITY_TYPE_MDS, CEPH_AUTH_CEPHX, &modes);
ASSERT_EQ(modes, secure_crc);
// back to normalish, for the benefit of the next test(s)
cct->_set_module_type(CEPH_ENTITY_TYPE_CLIENT);
}
| 10,284 | 40.471774 | 80 |
cc
|
null |
ceph-main/src/test/test_backfill.sh
|
#!/bin/sh
TEST_POOL=rbd
./stop.sh
CEPH_NUM_OSD=3 ./vstart.sh -d -n -x -o 'osd min pg log entries = 5'
./rados -p $TEST_POOL bench 15 write -b 4096
./ceph osd out 0
./init-ceph stop osd.0
./ceph osd down 0
./rados -p $TEST_POOL bench 600 write -b 4096
| 255 | 20.333333 | 67 |
sh
|
null |
ceph-main/src/test/test_c2c.cc
|
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "common/config.h"
#include "global/global_init.h"
#include "global/signal_handler.h"
#include "include/mempool.h"
#include <iostream>
#include <string>
using std::cerr;
using std::string;
static void usage(void)
{
cerr << "--threads number of threads (default 1)" << std::endl;
cerr << "--sharding activate sharding optimization" << std::endl;
}
mempool::shard_t shards[mempool::num_shards] = {0};
void sigterm_handler(int signum)
{
size_t total = 0;
for (auto& shard : shards) {
total += shard.bytes;
}
std::cout << total << std::endl;
exit(0);
}
int main(int argc, const char **argv)
{
int ret = 0;
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
int threads = 1;
bool sharding = false;
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
}
else if (ceph_argparse_witharg(args, i, &threads, cerr, "--threads", "-t", (char*)NULL)) {
}
else if (ceph_argparse_flag(args, i, "--sharding", "-s", (char*)NULL)) {
sharding = true;
}
else {
cerr << "unknown command line option: " << *i << std::endl;
cerr << std::endl;
usage();
return 2;
}
}
init_async_signal_handler();
register_async_signal_handler(SIGTERM, sigterm_handler);
std::vector<std::thread> workers;
for (int i = 0; i < threads; i++) {
workers.push_back(
std::thread([&](){
while(1) {
size_t i;
if (sharding) {
i = mempool::pool_t::pick_a_shard_int();
} else {
i = 0;
}
shards[i].bytes++;
}
}));
}
for (auto& t:workers) {
t.join();
}
workers.clear();
return ret;
}
| 1,927 | 20.662921 | 94 |
cc
|
null |
ceph-main/src/test/test_cfuse_cache_invalidate.cc
|
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "include/ceph_assert.h"
#define REGION 1048576
int main(int argc, char *argv[]) {
pid_t p = fork();
char buf[REGION];
memset(buf, 0, sizeof(buf));
if (p != 0) {
int done = 0;
int fd = open(argv[1], O_RDWR|O_CREAT, 0644);
if (fd < 0) {
perror(argv[1]);
return 1;
}
int i = 0;
while(!done) {
printf("writing %d\n", i++);
ceph_assert(pwrite(fd, buf, REGION, 0) == REGION);
int status;
int ret = waitpid(p, &status, WNOHANG);
ceph_assert(ret >= 0);
if (ret > 0) {
done = 1;
}
}
close(fd);
} else {
sleep(1);
int fd = open(argv[2], O_RDONLY, 0644);
if (fd < 0) {
perror(argv[2]);
return 1;
}
printf("reading\n");
ceph_assert(pread(fd, buf, REGION, 0) == REGION);
close(fd);
}
return 0;
}
| 1,005 | 17.290909 | 56 |
cc
|
null |
ceph-main/src/test/test_common.sh
|
#!/usr/bin/env bash
set -x
#
# test_common.sh
#
# Common routines for tests
#
#
# Environment variables that affect tests:
# KEEP_TEMPDIR If set, the tempdir will not be deleted
# when the test is over.
#
# Clean up the temporary directory
cleanup() {
if [ -n ${TEMPDIR} ]; then
rm -rf "${TEMPDIR}"
fi
}
# Create a temporary directory where test files will be stored.
setup_tempdir() {
TEMPDIR=`mktemp -d`
if [ -z $KEEP_TEMPDIR ]; then
trap cleanup INT TERM EXIT
fi
}
# Standard initialization function for tests
init() {
setup_tempdir
cd `dirname $0`/..
}
# Exit with an error message.
die() {
echo $@
exit 1
}
# Test that flag is set (the element is found in the list)
is_set()
{
local flag=$1; shift
local flags="$@"
local i
for i in ${flags}; do
if [ "${flag}" = "${i}" ]; then
return 0
fi
done
return 1
}
# Stop an OSD started by vstart
stop_osd() {
osd_index=$1
pidfile="out/osd.$osd_index.pid"
if [ -e $pidfile ]; then
if kill `cat $pidfile` ; then
poll_cmd "eval test -e $pidfile ; echo \$?" "1" 1 30
[ $? -eq 1 ] && return 0
echo "ceph-osd process did not terminate correctly"
else
echo "kill `cat $pidfile` failed"
fi
else
echo "ceph-osd process $osd_index is not running"
fi
return 1
}
# Restart an OSD started by vstart
restart_osd() {
osd_index=$1
./ceph-osd -i $osd_index -c ceph.conf &
}
# Ask the user a yes/no question and get the response
yes_or_no_choice() {
while true; do
echo -n "${1} [y/n] "
read ans
case "${ans}" in
y|Y|yes|YES|Yes) return 0 ;;
n|N|no|NO|No) return 1 ;;
*) echo "Please type yes or no."
echo ;;
esac
done
}
# Block until the user says "continue" or "c"
continue_prompt() {
prompt=${1:-"to go on"}
while true; do
echo "Please type 'c' or 'continue' ${prompt}."
read ans
case "${ans}" in
c|continue) return 0 ;;
*) echo ;;
esac
done
}
# Write a bunch of objects to rados
write_objects() {
start_ver=$1
stop_ver=$2
num_objs=$3
obj_size=$4
pool=$5
[ -d "${TEMPDIR}" ] || die "must setup_tempdir"
for v in `seq $start_ver $stop_ver`; do
chr=`perl -e "print chr(48+$v)"`
head -c $obj_size /dev/zero | tr '\0' "$chr" > $TEMPDIR/ver$v
for i in `seq -w 1 $num_objs`; do
./rados -c ./ceph.conf -p $pool put obj$i $TEMPDIR/ver$v || die "radostool failed"
done
done
}
read_objects() {
ver=$1
num_objs=$2
obj_size=$3
[ -d "${TEMPDIR}" ] || die "must setup_tempdir"
chr=`perl -e "print chr(48+$ver)"`
head -c $obj_size /dev/zero | tr '\0' "$chr" > $TEMPDIR/exemplar
for i in `seq -w 1 $num_objs`; do
./rados -c ./ceph.conf -p $pool get obj$i $TEMPDIR/out$i || die "radostool failed"
cmp $TEMPDIR/out$i $TEMPDIR/exemplar || die "got back incorrect obj$i"
done
}
poll_cmd() {
command=$1
search_str=$2
polling_interval=$3
total_time=$4
t=0
while [ $t -lt $total_time ]; do
$command | grep "$search_str"
[ $? -eq 0 ] && return 1
sleep $polling_interval
t=$(($t+$polling_interval))
done
return 0
}
dump_osd_store() {
set +x
echo "dumping osd store..."
find ./dev/osd* -type f | grep obj | grep head$ | sort | while read file; do
echo $file
head -c 10 $file
echo
done
}
start_recovery() {
CEPH_NUM_OSD=$1
osd=0
while [ $osd -lt $CEPH_NUM_OSD ]; do
./ceph -c ./ceph.conf tell osd.$osd debug kick_recovery_wq 0
osd=$((osd+1))
done
}
init
| 4,371 | 23.982857 | 106 |
sh
|
null |
ceph-main/src/test/test_cors.cc
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
extern "C"{
#include <curl/curl.h>
}
#include "common/ceph_crypto.h"
#include <map>
#include <list>
#define S3_BUCKET_NAME "s3testgw.fcgi"
#define SWIFT_BUCKET_NAME "swift3testgw.fcgi"
#define BUCKET_URL \
((g_test->get_key_type() == KEY_TYPE_S3)?(string("/" S3_BUCKET_NAME)):(string("/swift/v1/" SWIFT_BUCKET_NAME)))
#include <gtest/gtest.h>
#include "common/code_environment.h"
#include "common/ceph_argparse.h"
#include "common/Finisher.h"
#include "global/global_init.h"
#include "rgw_cors.h"
#include "rgw_cors_s3.h"
using namespace std;
#define CURL_VERBOSE 0
#define HTTP_RESPONSE_STR "RespCode"
#define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
extern "C" int ceph_armor(char *dst, const char *dst_end,
const char *src, const char *end);
enum key_type {
KEY_TYPE_UNDEFINED = 0,
KEY_TYPE_SWIFT,
KEY_TYPE_S3
};
static void print_usage(char *exec){
cout << "Usage: " << exec << " <Options>\n";
cout << "Options:\n"
"-g <gw-ip> - The ip address of the gateway\n"
"-p <gw-port> - The port number of the gateway\n"
"-k <SWIFT|S3> - The key type, either SWIFT or S3\n"
"-s3 <AWSAccessKeyId:SecretAccessKeyID> - Only, if the key type is S3, gives S3 credentials\n"
"-swift <Auth-Token> - Only if the key type is SWIFT, and gives the SWIFT credentials\n";
}
class test_cors_helper {
private:
string host;
string port;
string creds;
CURL *curl_inst;
map<string, string> response;
list<string> extra_hdrs;
string *resp_data;
unsigned resp_code;
key_type kt;
public:
test_cors_helper() : curl_inst(NULL), resp_data(NULL), resp_code(0), kt(KEY_TYPE_UNDEFINED){
curl_global_init(CURL_GLOBAL_ALL);
}
~test_cors_helper(){
curl_global_cleanup();
}
int send_request(string method, string uri,
size_t (*function)(void *,size_t,size_t,void *) = 0,
void *ud = 0, size_t length = 0);
int extract_input(unsigned argc, char *argv[]);
string& get_response(string hdr){
return response[hdr];
}
void set_extra_header(string hdr){
extra_hdrs.push_back(hdr);
}
void set_response(char *val);
void set_response_data(char *data, size_t len){
if(resp_data) delete resp_data;
resp_data = new string(data, len);
/*cout << resp_data->c_str() << "\n";*/
}
const string *get_response_data(){return resp_data;}
unsigned get_resp_code(){return resp_code;}
key_type get_key_type(){return kt;}
};
int test_cors_helper::extract_input(unsigned argc, char *argv[]){
#define ERR_CHECK_NEXT_PARAM(o) \
if((loop + 1) >= argc)return -1; \
else o = argv[loop+1];
for(unsigned loop = 1;loop < argc; loop += 2){
if(strcmp(argv[loop], "-g") == 0){
ERR_CHECK_NEXT_PARAM(host);
}else if(strcmp(argv[loop], "-k") == 0){
string type;
ERR_CHECK_NEXT_PARAM(type);
if(type.compare("S3") == 0)kt = KEY_TYPE_S3;
else if(type.compare("SWIFT") == 0)kt = KEY_TYPE_SWIFT;
}else if(strcmp(argv[loop],"-s3") == 0){
ERR_CHECK_NEXT_PARAM(creds);
}else if(strcmp(argv[loop],"-swift") == 0){
ERR_CHECK_NEXT_PARAM(creds);
}else if(strcmp(argv[loop],"-p") == 0){
ERR_CHECK_NEXT_PARAM(port);
}else return -1;
}
if(host.empty() || creds.empty())
return -1;
return 0;
}
void test_cors_helper::set_response(char *r){
string sr(r), h, v;
size_t off = sr.find(": ");
if(off != string::npos){
h.assign(sr, 0, off);
v.assign(sr, off + 2, sr.find("\r\n") - (off+2));
}else{
/*Could be the status code*/
if(sr.find("HTTP/") != string::npos){
h.assign(HTTP_RESPONSE_STR);
off = sr.find(" ");
v.assign(sr, off + 1, sr.find("\r\n") - (off + 1));
resp_code = atoi((v.substr(0, 3)).c_str());
}
}
response[h] = v;
}
size_t write_header(void *ptr, size_t size, size_t nmemb, void *ud){
test_cors_helper *h = static_cast<test_cors_helper *>(ud);
h->set_response((char *)ptr);
return size*nmemb;
}
size_t write_data(void *ptr, size_t size, size_t nmemb, void *ud){
test_cors_helper *h = static_cast<test_cors_helper *>(ud);
h->set_response_data((char *)ptr, size*nmemb);
return size*nmemb;
}
static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
{
int i;
str[0] = '\0';
for (i = 0; i < len; i++) {
sprintf(&str[i*2], "%02x", (int)buf[i]);
}
}
static void calc_hmac_sha1(const char *key, int key_len,
const char *msg, int msg_len, char *dest)
/* destination should be CEPH_CRYPTO_HMACSHA1_DIGESTSIZE bytes long */
{
ceph::crypto::HMACSHA1 hmac((const unsigned char *)key, key_len);
hmac.Update((const unsigned char *)msg, msg_len);
hmac.Final((unsigned char *)dest);
char hex_str[(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2) + 1];
buf_to_hex((unsigned char *)dest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE, hex_str);
}
static int get_s3_auth(const string &method, string creds, const string &date, const string &res, string& out){
string aid, secret, auth_hdr;
size_t off = creds.find(":");
out = "";
if(off != string::npos){
aid.assign(creds, 0, off);
secret.assign(creds, off + 1, string::npos);
/*sprintf(auth_hdr, "%s\n\n\n%s\n%s", req_type, date, res);*/
char hmac_sha1[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
char b64[65]; /* 64 is really enough */
auth_hdr.append(method + string("\n\n\n") + date + string("\n") + res);
calc_hmac_sha1(secret.c_str(), secret.length(), auth_hdr.c_str(), auth_hdr.length(), hmac_sha1);
int ret = ceph_armor(b64, b64 + 64, hmac_sha1,
hmac_sha1 + CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
if (ret < 0) {
cout << "ceph_armor failed\n";
return -1;
}
b64[ret] = 0;
out.append(aid + string(":") + b64);
}else return -1;
return 0;
}
void get_date(string& d){
struct timeval tv;
char date[64];
struct tm tm;
char *days[] = {(char *)"Sun", (char *)"Mon", (char *)"Tue",
(char *)"Wed", (char *)"Thu", (char *)"Fri",
(char *)"Sat"};
char *months[] = {(char *)"Jan", (char *)"Feb", (char *)"Mar",
(char *)"Apr", (char *)"May", (char *)"Jun",
(char *)"Jul",(char *) "Aug", (char *)"Sep",
(char *)"Oct", (char *)"Nov", (char *)"Dec"};
gettimeofday(&tv, NULL);
gmtime_r(&tv.tv_sec, &tm);
sprintf(date, "%s, %d %s %d %d:%d:%d GMT",
days[tm.tm_wday],
tm.tm_mday, months[tm.tm_mon],
tm.tm_year + 1900,
tm.tm_hour, tm.tm_min, 0 /*tm.tm_sec*/);
d = date;
}
int test_cors_helper::send_request(string method, string res,
size_t (*read_function)( void *,size_t,size_t,void *),
void *ud,
size_t length){
string url;
string auth, date;
url.append(string("http://") + host);
if(port.length() > 0)url.append(string(":") + port);
url.append(res);
curl_inst = curl_easy_init();
if(curl_inst){
curl_easy_setopt(curl_inst, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl_inst, CURLOPT_CUSTOMREQUEST, method.c_str());
curl_easy_setopt(curl_inst, CURLOPT_VERBOSE, CURL_VERBOSE);
curl_easy_setopt(curl_inst, CURLOPT_HEADERFUNCTION, write_header);
curl_easy_setopt(curl_inst, CURLOPT_WRITEHEADER, (void *)this);
curl_easy_setopt(curl_inst, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl_inst, CURLOPT_WRITEDATA, (void *)this);
if(read_function){
curl_easy_setopt(curl_inst, CURLOPT_READFUNCTION, read_function);
curl_easy_setopt(curl_inst, CURLOPT_READDATA, (void *)ud);
curl_easy_setopt(curl_inst, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl_inst, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
}
get_date(date);
string http_date;
http_date.append(string("Date: ") + date);
if(kt == KEY_TYPE_S3){
string s3auth;
if(get_s3_auth(method, creds, date, res, s3auth) < 0)return -1;
auth.append(string("Authorization: AWS ") + s3auth);
} else if(kt == KEY_TYPE_SWIFT){
auth.append(string("X-Auth-Token: ") + creds);
} else {
cout << "Unknown state (" << kt << ")\n";
return -1;
}
struct curl_slist *slist = NULL;
slist = curl_slist_append(slist, auth.c_str());
slist = curl_slist_append(slist, http_date.c_str());
for(list<string>::iterator it = extra_hdrs.begin();
it != extra_hdrs.end(); ++it){
slist = curl_slist_append(slist, (*it).c_str());
}
if(read_function)
curl_slist_append(slist, "Expect:");
curl_easy_setopt(curl_inst, CURLOPT_HTTPHEADER, slist);
response.erase(response.begin(), response.end());
extra_hdrs.erase(extra_hdrs.begin(), extra_hdrs.end());
CURLcode res = curl_easy_perform(curl_inst);
if(res != CURLE_OK){
cout << "Curl perform failed for " << url << ", res: " <<
curl_easy_strerror(res) << "\n";
return -1;
}
curl_slist_free_all(slist);
}
curl_easy_cleanup(curl_inst);
return 0;
}
test_cors_helper *g_test;
Finisher *finisher;
static int create_bucket(void){
if(g_test->get_key_type() == KEY_TYPE_S3){
g_test->send_request(string("PUT"), string("/" S3_BUCKET_NAME));
if(g_test->get_resp_code() != 200U){
cout << "Error creating bucket, http code " << g_test->get_resp_code();
return -1;
}
}else if(g_test->get_key_type() == KEY_TYPE_SWIFT){
g_test->send_request(string("PUT"), string("/swift/v1/" SWIFT_BUCKET_NAME));
if(g_test->get_resp_code() != 201U){
cout << "Error creating bucket, http code " << g_test->get_resp_code();
return -1;
}
}else return -1;
return 0;
}
static int delete_bucket(void){
if(g_test->get_key_type() == KEY_TYPE_S3){
g_test->send_request(string("DELETE"), string("/" S3_BUCKET_NAME));
if(g_test->get_resp_code() != 204U){
cout << "Error deleting bucket, http code " << g_test->get_resp_code();
return -1;
}
}else if(g_test->get_key_type() == KEY_TYPE_SWIFT){
g_test->send_request(string("DELETE"), string("/swift/v1/" SWIFT_BUCKET_NAME));
if(g_test->get_resp_code() != 204U){
cout << "Error deleting bucket, http code " << g_test->get_resp_code();
return -1;
}
}else return -1;
return 0;
}
RGWCORSRule *xml_to_cors_rule(string s){
RGWCORSConfiguration_S3 *cors_config;
const DoutPrefix dp(g_ceph_context, 1, "test cors: ");
RGWCORSXMLParser_S3 parser(&dp, g_ceph_context);
const string *data = g_test->get_response_data();
if (!parser.init()) {
return NULL;
}
if (!parser.parse(data->c_str(), data->length(), 1)) {
return NULL;
}
cors_config = (RGWCORSConfiguration_S3 *)parser.find_first("CORSConfiguration");
if (!cors_config) {
return NULL;
}
return cors_config->host_name_rule(s.c_str());
}
size_t cors_read_xml(void *ptr, size_t s, size_t n, void *ud){
stringstream *ss = (stringstream *)ud;
size_t len = ss->str().length();
if(s*n < len){
cout << "Cannot copy xml data, as len is not enough\n";
return 0;
}
memcpy(ptr, (void *)ss->str().c_str(), len);
return len;
}
void send_cors(set<string> o, set<string> h,
list<string> e, uint8_t flags,
unsigned max_age){
if(g_test->get_key_type() == KEY_TYPE_S3){
RGWCORSRule rule(o, h, e, flags, max_age);
RGWCORSConfiguration config;
config.stack_rule(rule);
stringstream ss;
RGWCORSConfiguration_S3 *s3;
s3 = static_cast<RGWCORSConfiguration_S3 *>(&config);
s3->to_xml(ss);
g_test->send_request(string("PUT"), string("/" S3_BUCKET_NAME "?cors"), cors_read_xml,
(void *)&ss, ss.str().length());
}else if(g_test->get_key_type() == KEY_TYPE_SWIFT){
set<string>::iterator it;
string a_o;
for(it = o.begin(); it != o.end(); ++it){
if(a_o.length() > 0)a_o.append(" ");
a_o.append(*it);
}
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Allow-Origin: ") + a_o);
if(!h.empty()){
string a_h;
for(it = h.begin(); it != h.end(); ++it){
if(a_h.length() > 0)a_h.append(" ");
a_h.append(*it);
}
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Allow-Headers: ") + a_h);
}
if(!e.empty()){
string e_h;
for(list<string>::iterator lit = e.begin(); lit != e.end(); ++lit){
if(e_h.length() > 0)e_h.append(" ");
e_h.append(*lit);
}
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Expose-Headers: ") + e_h);
}
if(max_age != CORS_MAX_AGE_INVALID){
char age[32];
sprintf(age, "%u", max_age);
g_test->set_extra_header(string("X-Container-Meta-Access-Control-Max-Age: ") + string(age));
}
//const char *data = "1";
stringstream ss;
ss << "1";
g_test->send_request(string("POST"), string("/swift/v1/" SWIFT_BUCKET_NAME), cors_read_xml,
(void *)&ss, 1);
}
}
TEST(TestCORS, getcors_firsttime){
if(g_test->get_key_type() == KEY_TYPE_SWIFT)return;
ASSERT_EQ(0, create_bucket());
g_test->send_request(string("GET"), string("/" S3_BUCKET_NAME "?cors"));
EXPECT_EQ(404U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, putcors_firsttime){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
/*Now get the CORS and check if its fine*/
if(g_test->get_key_type() == KEY_TYPE_S3){
g_test->send_request(string("GET"), string("/" S3_BUCKET_NAME "?cors"));
EXPECT_EQ(200U, g_test->get_resp_code());
RGWCORSRule *r = xml_to_cors_rule(string("example.com"));
EXPECT_TRUE(r != NULL);
if(!r)return;
EXPECT_TRUE((r->get_allowed_methods() & (RGW_CORS_GET | RGW_CORS_PUT))
== (RGW_CORS_GET | RGW_CORS_PUT));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, putcors_invalid_hostname){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*.example.*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
if((g_test->get_key_type() != KEY_TYPE_SWIFT)){
origins.insert(origins.end(), "");
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, putcors_invalid_headers){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "www.example.com");
h.insert(h.end(), "*-Header-*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
h.erase(h.begin(), h.end());
if((g_test->get_key_type() != KEY_TYPE_SWIFT)){
h.insert(h.end(), "");
flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ((400U), g_test->get_resp_code());
h.erase(h.begin(), h.end());
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_1){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*.example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: a.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: SomeHeader"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("a.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0U, s.length());
s = g_test->get_response(string("Access-Control-Max-Age"));
EXPECT_EQ(0U, s.length());
s = g_test->get_response(string("Access-Control-Expose-Headers"));
EXPECT_EQ(0U, s.length());
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_2){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*.example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT | RGW_CORS_DELETE | RGW_CORS_HEAD;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: a.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: HEAD"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("a.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("HEAD"));
}
g_test->set_extra_header(string("Origin: foo.bar.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: HEAD"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("HEAD"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_3){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT | RGW_CORS_DELETE | RGW_CORS_HEAD;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
/*Check for HEAD in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: a.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: HEAD"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("a.example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("HEAD"));
}
/*Check for DELETE in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: foo.bar"));
g_test->set_extra_header(string("Access-Control-Request-Method: DELETE"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("DELETE"));
}
/*Check for PUT in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: foo.bar"));
g_test->set_extra_header(string("Access-Control-Request-Method: PUT"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("PUT"));
}
/*Check for POST in Access-Control-Allow-Methods*/
g_test->set_extra_header(string("Origin: foo.bar"));
g_test->set_extra_header(string("Access-Control-Request-Method: POST"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("foo.bar"));
if(g_test->get_key_type() == KEY_TYPE_S3){
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0U, s.length());
}else{
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("POST"));
}
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_4){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
h.insert(h.end(), "Header1");
h.insert(h.end(), "Header2");
h.insert(h.end(), "*");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0U, s.length());
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header2"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header2"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header2, Header1"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header2,Header1"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1, Header2"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1,Header2"));
}
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1, Header2, Header3"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1,Header2,Header3"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_5){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
e.insert(e.end(), "Expose1");
e.insert(e.end(), "Expose2");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Expose-Headers"));
EXPECT_EQ(0, s.compare("Expose1,Expose2"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_6){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
unsigned err = (g_test->get_key_type() == KEY_TYPE_SWIFT)?401U:403U;
origins.insert(origins.end(), "http://www.example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
origins.insert(origins.end(), "*.example.com");
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: .example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: https://www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
origins.erase(origins.begin(), origins.end());
origins.insert(origins.end(), "https://example*.com");
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: https://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: http://example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: www.example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(err, g_test->get_resp_code());
g_test->set_extra_header(string("Origin: https://example.a.b.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, optionscors_test_options_7){
ASSERT_EQ(0, create_bucket());
set<string> origins, h;
list<string> e;
origins.insert(origins.end(), "example.com");
h.insert(h.end(), "Header*");
h.insert(h.end(), "Hdr-*-Length");
h.insert(h.end(), "*-Length");
h.insert(h.end(), "foo*foo");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->set_extra_header(string("Origin: example.com"));
g_test->set_extra_header(string("Access-Control-Request-Method: GET"));
g_test->set_extra_header(string("Access-Control-Allow-Headers: Header1, Header2, Header3, "
"Hdr--Length, Hdr-1-Length, Header-Length, Content-Length, foofoofoo"));
g_test->send_request(string("OPTIONS"), BUCKET_URL);
EXPECT_EQ(200U, g_test->get_resp_code());
if(g_test->get_resp_code() == 200){
string s = g_test->get_response(string("Access-Control-Allow-Origin"));
EXPECT_EQ(0, s.compare("example.com"));
s = g_test->get_response(string("Access-Control-Allow-Methods"));
EXPECT_EQ(0, s.compare("GET"));
s = g_test->get_response(string("Access-Control-Allow-Headers"));
EXPECT_EQ(0, s.compare("Header1,Header2,Header3,"
"Hdr--Length,Hdr-1-Length,Header-Length,Content-Length,foofoofoo"));
}
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, deletecors_firsttime){
if(g_test->get_key_type() == KEY_TYPE_SWIFT)return;
ASSERT_EQ(0, create_bucket());
g_test->send_request("DELETE", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(204U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
TEST(TestCORS, deletecors_test){
set<string> origins, h;
list<string> e;
if(g_test->get_key_type() == KEY_TYPE_SWIFT)return;
ASSERT_EQ(0, create_bucket());
origins.insert(origins.end(), "example.com");
uint8_t flags = RGW_CORS_GET | RGW_CORS_PUT;
send_cors(origins, h, e, flags, CORS_MAX_AGE_INVALID);
EXPECT_EQ(((g_test->get_key_type() == KEY_TYPE_SWIFT)?202U:200U), g_test->get_resp_code());
g_test->send_request("GET", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(200U, g_test->get_resp_code());
g_test->send_request("DELETE", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(204U, g_test->get_resp_code());
g_test->send_request("GET", "/" S3_BUCKET_NAME "?cors");
EXPECT_EQ(404U, g_test->get_resp_code());
ASSERT_EQ(0, delete_bucket());
}
int main(int argc, char *argv[]){
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
g_test = new test_cors_helper();
finisher = new Finisher(g_ceph_context);
#ifdef GTEST
::testing::InitGoogleTest(&argc, argv);
#endif
finisher->start();
if(g_test->extract_input((unsigned)argc, argv) < 0){
print_usage(argv[0]);
return -1;
}
#ifdef GTEST
int r = RUN_ALL_TESTS();
if (r >= 0) {
cout << "There are failures in the test case\n";
return -1;
}
#endif
finisher->stop();
delete g_test;
delete finisher;
return 0;
}
| 34,226 | 36.945676 | 113 |
cc
|
null |
ceph-main/src/test/test_crush_bucket.sh
|
#!/usr/bin/env bash
#Generic test_crush_bucket test
#
# Includes
source $(dirname $0)/detect-build-env-vars.sh
source ../qa/standalone/ceph-helpers.sh
function run() {
local dir=$1
shift
export CEPH_MON="127.0.0.1:17119" # git grep '\<17119\>' : there must be only one
export CEPH_ARGS
CEPH_ARGS+="--fsid=$(uuidgen) --auth-supported=none "
CEPH_ARGS+="--mon-host=$CEPH_MON "
local funcs=${@:-$(set | ${SED} -n -e 's/^\(TEST_[0-9a-z_]*\) .*/\1/p')}
for func in $funcs ; do
$func $dir || return 1
done
}
function TEST_crush_bucket() {
local dir=$1
setup $dir || return 1
run_mon $dir a || return 1
run_osd $dir 0 || return 1
run_osd $dir 1 || return 1
run_osd $dir 2 || return 1
ceph osd getcrushmap -o "$dir/map1" || return 1
crushtool -d "$dir/map1" -o "$dir/map1.txt"|| return 1
local var=`ceph osd crush dump|grep -w id|grep '-'|grep -Eo '[0-9]+'|sort|uniq|${SED} -n '$p'`
local id=`expr $var + 1`
local item=`${SED} -n '/^root/,/}/p' $dir/map1.txt|grep 'item'|head -1`
local weight=`${SED} -n '/^root/,/}/p' $dir/map1.txt|grep 'item'|head -1|awk '{print $4}'`
local bucket="host test {\n id -$id\n # weight $weight\n alg straw \n hash 0 # rjenkins1 \n $item\n}\n"
${SED} -i "/# buckets/a\ $bucket" "$dir/map1.txt"
crushtool -c "$dir/map1.txt" -o "$dir/map1.bin" 2>"$dir/rev"
local result=$(cat "$dir/rev")
if [ "$result" != "" ];
then
return 1
fi
}
main testcrushbucket
| 1,516 | 27.622642 | 108 |
sh
|
null |
ceph-main/src/test/test_csyn.sh
|
#!/usr/bin/env bash
set -x
#
# Runs the synthetic client
#
# Includes
source "`dirname $0`/test_common.sh"
# Functions
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
# set recovery start to a really long time to ensure that we don't start recovery
./vstart.sh -d -n -o 'osd recovery delay start = 10000
osd max scrubs = 0' || die "vstart failed"
}
csyn_simple1_impl() {
./ceph-syn -c ./ceph.conf --syn writefile 100 1000 --syn writefile 100 1000 || die "csyn failed"
}
csyn_simple1() {
setup 2
csyn_simple1_impl
}
run() {
csyn_simple1 || die "test failed"
}
$@
| 633 | 16.135135 | 98 |
sh
|
null |
ceph-main/src/test/test_denc.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2016 Red Hat
*
* Author: Sage Weil <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include <numeric>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#include "include/denc.h"
using namespace std;
// test helpers
template<typename T>
void test_encode_decode(T v) {
bufferlist bl;
encode(v, bl);
auto p = bl.cbegin();
T out;
decode(out, p);
ASSERT_EQ(v, out);
}
template<typename T>
void test_denc(T v) {
// estimate
size_t s = 0;
denc(v, s);
ASSERT_NE(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(v, a);
}
ASSERT_LE(bl.length(), s);
// decode
bl.rebuild();
T out;
auto bpi = bl.front().begin();
denc(out, bpi);
ASSERT_EQ(v, out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
// test glue
test_encode_decode(v);
}
template<typename T>
void test_encode_decode_featured(T v) {
bufferlist bl;
encode(v, bl, 123);
auto p = bl.cbegin();
T out;
decode(out, p);
ASSERT_EQ(v, out);
}
template<typename T>
void test_denc_featured(T v) {
// estimate
size_t s = 0;
denc(v, s, 0);
ASSERT_GT(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(v, a, 1);
}
ASSERT_LE(bl.length(), s);
// decode
bl.rebuild();
T out;
auto bpi = bl.front().begin();
denc(out, bpi, 1);
ASSERT_EQ(v, out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
// test glue
test_encode_decode_featured(v);
}
// hooks to count bound calls
struct counts_t {
int num_bound_encode = 0;
int num_encode = 0;
int num_decode = 0;
void reset() {
num_bound_encode = 0;
num_encode = 0;
num_decode = 0;
}
} counts;
struct denc_counter_t {
void bound_encode(size_t& p) const {
++counts.num_bound_encode;
++p; // denc.h does not like 0-length objects
}
void encode(buffer::list::contiguous_appender& p) const {
p.append("a", 1);
++counts.num_encode;
}
void decode(buffer::ptr::const_iterator &p) {
p += 1;
++counts.num_decode;
}
};
WRITE_CLASS_DENC(denc_counter_t)
struct denc_counter_bounded_t {
void bound_encode(size_t& p) const {
++counts.num_bound_encode;
++p; // denc.h does not like 0-length objects
}
void encode(buffer::list::contiguous_appender& p) const {
p.append("a", 1);
++counts.num_encode;
}
void decode(buffer::ptr::const_iterator &p) {
p += 1;
++counts.num_decode;
}
};
WRITE_CLASS_DENC_BOUNDED(denc_counter_bounded_t)
TEST(denc, denc_counter)
{
denc_counter_t single, single2;
{
bufferlist bl;
encode(single, bl);
decode(single2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 1);
ASSERT_EQ(counts.num_encode, 1);
ASSERT_EQ(counts.num_decode, 1);
counts.reset();
}
TEST(denc, simple)
{
test_denc((uint8_t)4);
test_denc((int8_t)-5);
test_denc((uint16_t)6);
test_denc((int16_t)-7);
test_denc((uint32_t)8);
test_denc((int32_t)-9);
test_denc((uint64_t)10);
test_denc((int64_t)-11);
}
TEST(denc, string)
{
string a, b("hi"), c("multi\nline\n");
test_denc(a);
test_denc(b);
test_denc(c);
}
struct legacy_t {
int32_t a = 1;
void encode(bufferlist& bl) const {
using ceph::encode;
encode(a, bl);
}
void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(a, p);
}
legacy_t() {}
explicit legacy_t(int32_t i) : a(i) {}
friend bool operator<(const legacy_t& l, const legacy_t& r) {
return l.a < r.a;
}
friend bool operator==(const legacy_t& l, const legacy_t& r) {
return l.a == r.a;
}
};
WRITE_CLASS_ENCODER(legacy_t)
template<template<class> class C>
void test_common_veclist(const char* c) {
{
cout << c << "<std::string>" << std::endl;
C<std::string> s;
s.push_back("foo");
s.push_back("bar");
s.push_back("baz");
counts.reset();
test_denc(s);
}
{
cout << c << "<int32_t>" << std::endl;
C<int32_t> s;
s.push_back(1);
s.push_back(2);
s.push_back(3);
test_denc(s);
}
{
cout << c << "<legacy_t>" << std::endl;
C<legacy_t> s;
s.push_back(legacy_t(1));
s.push_back(legacy_t(2));
test_encode_decode(s);
}
}
// We only care about specializing the type, all other template
// parameters should have the default values. (Like first-class
// functions, first-class templates do not bring their defaults.)
template<typename T>
using default_vector = std::vector<T>;
TEST(denc, vector)
{
test_common_veclist<default_vector>("std::vector");
{
counts.reset();
vector<denc_counter_t> v, v2;
v.resize(100);
{
bufferlist bl;
encode(v, bl);
decode(v2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 100);
ASSERT_EQ(counts.num_encode, 100);
ASSERT_EQ(counts.num_decode, 100);
}
{
counts.reset();
vector<denc_counter_bounded_t> v, v2;
v.resize(100);
{
bufferlist bl;
encode(v, bl);
decode(v2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 1);
ASSERT_EQ(counts.num_encode, 100);
ASSERT_EQ(counts.num_decode, 100);
}
}
template<typename T>
using default_list = std::list<T>;
TEST(denc, list)
{
test_common_veclist<default_list>("std::list");
{
counts.reset();
list<denc_counter_bounded_t> l, l2;
for (unsigned i=0; i<100; ++i) {
l.emplace_back(denc_counter_bounded_t());
}
{
bufferlist bl;
encode(l, bl);
decode(l2, bl);
}
ASSERT_EQ(counts.num_bound_encode, 1);
ASSERT_EQ(counts.num_encode, 100);
ASSERT_EQ(counts.num_decode, 100);
}
}
template<template<class> class C>
void test_setlike(const char* c) {
{
cout << c << "<std::string>" << std::endl;
C<std::string> s;
s.insert("foo");
s.insert("bar");
s.insert("baz");
test_denc(s);
}
{
cout << c << "<int32_t>" << std::endl;
C<int32_t> s;
s.insert(1);
s.insert(2);
s.insert(3);
test_denc(s);
}
{
cout << c << "<legacy_t>" << std::endl;
C<legacy_t> s;
s.insert(legacy_t(1));
s.insert(legacy_t(2));
test_encode_decode(s);
}
}
template<typename T>
using default_set = std::set<T>;
TEST(denc, set)
{
test_setlike<default_set>("std::set");
}
template<typename T>
using default_flat_set= boost::container::flat_set<T>;
TEST(denc, flat_set)
{
test_setlike<default_flat_set>("std::set");
}
struct foo_t {
int32_t a = 0;
uint64_t b = 123;
DENC(foo_t, v, p) {
DENC_START(1, 1, p);
::denc(v.a, p);
::denc(v.b, p);
DENC_FINISH(p);
}
friend bool operator==(const foo_t& l, const foo_t& r) {
return l.a == r.a && l.b == r.b;
}
};
WRITE_CLASS_DENC_BOUNDED(foo_t)
struct foo2_t {
int32_t c = 0;
uint64_t d = 123;
DENC(foo2_t, v, p) {
DENC_START(1, 1, p);
::denc(v.c, p);
::denc(v.d, p);
DENC_FINISH(p);
}
friend bool operator==(const foo2_t& l, const foo2_t& r) {
return l.c == r.c && l.d == r.d;
}
};
WRITE_CLASS_DENC_BOUNDED(foo2_t)
struct bar_t {
int32_t a = 0;
uint64_t b = 123;
DENC_FEATURED(bar_t, v, p, f) {
::denc(v.a, p, f);
::denc(v.b, p, f);
}
friend bool operator==(const bar_t& l, const bar_t& r) {
return l.a == r.a && l.b == r.b;
}
};
WRITE_CLASS_DENC_FEATURED_BOUNDED(bar_t)
TEST(denc, foo)
{
foo_t a;
test_denc(a);
bufferlist bl;
encode(a, bl);
bl.hexdump(cout);
}
TEST(denc, bar)
{
bar_t a;
test_denc_featured(a);
}
TEST(denc, pair)
{
pair<int32_t,std::string> p;
bufferlist bl;
{
auto a = bl.get_contiguous_appender(1000);
denc(p, a);
encode(p, bl);
}
pair<int32_t,legacy_t> lp;
encode(lp, bl);
}
template<template<class, class> class C>
void test_common_maplike(const char* c) {
{
cout << c << "<std::string, foo_t>" << std::endl;
C<string, foo_t> s;
s["foo"] = foo_t();
s["bar"] = foo_t();
s["baz"] = foo_t();
test_denc(s);
}
{
cout << c << "<std::string, bar_t>" << std::endl;
C<string, bar_t> s;
s["foo"] = bar_t();
s["bar"] = bar_t();
s["baz"] = bar_t();
test_denc_featured(s);
}
{
cout << c << "<std::string, legacy_t>" << std::endl;
C<std::string, legacy_t> s;
s["foo"] = legacy_t(1);
s["bar"] = legacy_t(2);
test_encode_decode(s);
}
}
template<typename U, typename V>
using default_map = std::map<U, V>;
TEST(denc, map)
{
test_common_maplike<default_map>("std::map");
}
template<typename U, typename V>
using default_flat_map = boost::container::flat_map<U, V>;
TEST(denc, flat_map)
{
test_common_maplike<default_flat_map>("boost::container::flat_map");
}
TEST(denc, bufferptr_shallow_and_deep) {
// shallow encode
int32_t i = 1;
bufferptr p1("foo", 3);
bufferlist bl;
{
auto a = bl.get_contiguous_appender(100);
denc(i, a);
denc(p1, a);
denc(i, a);
}
cout << "bl is " << bl << std::endl;
bl.hexdump(cout);
ASSERT_EQ(3u, bl.get_num_buffers());
bufferlist bl2 = bl;
bl.rebuild();
bl2.rebuild();
// shallow decode
{
cout << "bl is " << bl << std::endl;
bl.hexdump(cout);
auto p = bl.front().begin();
bufferptr op;
int32_t i;
denc(i, p);
denc(op, p);
denc(i, p);
ASSERT_EQ(3u, op.length());
ASSERT_EQ('f', op[0]);
memset(bl.c_str(), 0, bl.length());
ASSERT_EQ(0, op[0]);
}
// deep decode
{
cout << "bl is " << bl2 << std::endl;
bl2.hexdump(cout);
auto p = bl2.front().begin_deep();
bufferptr op;
int32_t i;
denc(i, p);
denc(op, p);
denc(i, p);
ASSERT_EQ('f', op[0]);
memset(bl2.c_str(), 1, bl2.length());
ASSERT_EQ('f', op[0]);
}
}
TEST(denc, array)
{
{
cout << "std::array<std::string, 3>" << std::endl;
std::array<std::string, 3> s = { "foo", "bar", "baz" };
counts.reset();
test_denc(s);
}
{
cout << "std::array<uint32_t, 3>" << std::endl;
std::array<uint32_t, 3> s = { 1UL, 2UL, 3UL };
test_denc(s);
}
}
TEST(denc, tuple)
{
{
cout << "std::tuple<uint64_t, uint32_t>" << std::endl;
std::tuple<uint64_t, uint32_t> s(100ULL, 97UL);
counts.reset();
test_denc(s);
}
{
cout << "std::tuple<std::string, uint3_t>" << std::endl;
std::tuple<std::string, uint32_t> s("foo", 97);
test_denc(s);
}
{
cout << "std::tuple<std::string, std::set<uint32_t>>" << std::endl;
std::tuple<std::string, std::set<uint32_t>> s(
"bar", std::set<uint32_t>{uint32_t(1), uint32_t(2), uint32_t(3)});
test_denc(s);
}
}
TEST(denc, optional)
{
{
cout << "boost::optional<uint64_t>" << std::endl;
boost::optional<uint64_t> s = 97, t = boost::none;
counts.reset();
test_denc(s);
test_denc(t);
}
{
cout << "boost::optional<std::string>" << std::endl;
boost::optional<std::string> s = std::string("Meow"), t = boost::none;
counts.reset();
test_denc(s);
test_denc(t);
}
{
size_t s = 0;
denc(boost::none, s);
ASSERT_NE(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(boost::none, a);
}
ASSERT_LE(bl.length(), s);
bl.rebuild();
boost::optional<uint32_t> out = 5;
auto bpi = bl.front().begin();
denc(out, bpi);
ASSERT_FALSE(!!out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
}
}
TEST(denc, stdoptional)
{
{
cout << "std::optional<uint64_t>" << std::endl;
std::optional<uint64_t> s = 97, t = std::nullopt;
counts.reset();
test_denc(s);
test_denc(t);
}
{
cout << "std::optional<std::string>" << std::endl;
std::optional<std::string> s = std::string("Meow"), t = std::nullopt;
counts.reset();
test_denc(s);
test_denc(t);
}
{
size_t s = 0;
denc(std::nullopt, s);
ASSERT_NE(s, 0u);
// encode
bufferlist bl;
{
auto a = bl.get_contiguous_appender(s);
denc(std::nullopt, a);
}
ASSERT_LE(bl.length(), s);
bl.rebuild();
std::optional<uint32_t> out = 5;
auto bpi = bl.front().begin();
denc(out, bpi);
ASSERT_FALSE(!!out);
ASSERT_EQ(bpi.get_pos(), bl.c_str() + bl.length());
}
}
// unlike legacy_t, Legacy supports denc() also.
struct Legacy {
static unsigned n_denc;
static unsigned n_decode;
uint8_t value = 0;
DENC(Legacy, v, p) {
n_denc++;
denc(v.value, p);
}
void decode(buffer::list::const_iterator& p) {
n_decode++;
using ceph::decode;
decode(value, p);
}
static void reset() {
n_denc = n_decode = 0;
}
static bufferlist encode_n(unsigned n, const vector<unsigned>& segments);
};
WRITE_CLASS_DENC(Legacy)
unsigned Legacy::n_denc = 0;
unsigned Legacy::n_decode = 0;
bufferlist Legacy::encode_n(unsigned n, const vector<unsigned>& segments) {
vector<Legacy> v;
for (unsigned i = 0; i < n; i++) {
v.push_back(Legacy());
}
bufferlist bl(n * sizeof(uint8_t));
using ceph::encode;
encode(v, bl);
bufferlist segmented;
auto p = bl.begin();
auto sum = std::accumulate(segments.begin(), segments.end(), 0u);
ceph_assert(sum != 0u);
for (auto i : segments) {
buffer::ptr seg;
p.copy_deep(bl.length() * i / sum, seg);
segmented.push_back(seg);
}
p.copy_all(segmented);
return segmented;
}
TEST(denc, no_copy_if_segmented_and_lengthy)
{
static_assert(_denc::has_legacy_denc<Legacy>::value,
"Legacy do have legacy denc");
{
// use denc() which shallow_copy() if the buffer is small
constexpr unsigned N_COPIES = 42;
const vector<unsigned> segs{50, 50}; // half-half
bufferlist segmented = Legacy::encode_n(N_COPIES, segs);
ASSERT_GT(segmented.get_num_buffers(), 1u);
ASSERT_LT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
vector<Legacy> v;
// denc() is shared by encode() and decode(), so reset() right before
// decode()
Legacy::reset();
decode(v, p);
ASSERT_EQ(N_COPIES, v.size());
ASSERT_EQ(N_COPIES, Legacy::n_denc);
ASSERT_EQ(0u, Legacy::n_decode);
}
{
// use denc() which shallow_copy() if the buffer is not segmented and large
const unsigned N_COPIES = CEPH_PAGE_SIZE * 2;
const vector<unsigned> segs{100};
bufferlist segmented = Legacy::encode_n(N_COPIES, segs);
ASSERT_EQ(segmented.get_num_buffers(), 1u);
ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
vector<Legacy> v;
Legacy::reset();
decode(v, p);
ASSERT_EQ(N_COPIES, v.size());
ASSERT_EQ(N_COPIES, Legacy::n_denc);
ASSERT_EQ(0u, Legacy::n_decode);
}
{
// use denc() which shallow_copy() if the buffer is segmented and large,
// but the total size of the chunks to be decoded is smallish.
bufferlist large_bl = Legacy::encode_n(CEPH_PAGE_SIZE * 2, {50, 50});
bufferlist small_bl = Legacy::encode_n(100, {50, 50});
bufferlist segmented;
segmented.append(large_bl);
segmented.append(small_bl);
ASSERT_GT(segmented.get_num_buffers(), 1u);
ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
p += large_bl.length();
ASSERT_LT(segmented.length() - p.get_off(), CEPH_PAGE_SIZE);
vector<Legacy> v;
Legacy::reset();
decode(v, p);
ASSERT_EQ(Legacy::n_denc, 100u);
ASSERT_EQ(0u, Legacy::n_decode);
}
{
// use decode() which avoids deep copy if the buffer is segmented and large
bufferlist small_bl = Legacy::encode_n(100, {50, 50});
bufferlist large_bl = Legacy::encode_n(CEPH_PAGE_SIZE * 2, {50, 50});
bufferlist segmented;
segmented.append(small_bl);
segmented.append(large_bl);
ASSERT_GT(segmented.get_num_buffers(), 1u);
ASSERT_GT(segmented.length(), CEPH_PAGE_SIZE);
auto p = segmented.cbegin();
p += small_bl.length();
ASSERT_GT(segmented.length() - p.get_off(), CEPH_PAGE_SIZE);
vector<Legacy> v;
Legacy::reset();
decode(v, p);
ASSERT_EQ(0u, Legacy::n_denc);
ASSERT_EQ(CEPH_PAGE_SIZE * 2, Legacy::n_decode);
}
}
| 16,370 | 21.004032 | 79 |
cc
|
null |
ceph-main/src/test/test_features.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <stdio.h>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "common/ceph_releases.h"
#include "common/ceph_strings.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#include "include/ceph_features.h"
using namespace std;
TEST(features, release_features)
{
for (int r = 1; r < CEPH_RELEASE_MAX; ++r) {
const char *name = ceph_release_name(r);
ASSERT_NE(string("unknown"), name);
ASSERT_EQ(ceph_release_t{static_cast<uint8_t>(r)},
ceph_release_from_name(name));
uint64_t features = ceph_release_features(r);
int rr = ceph_release_from_features(features);
cout << r << " " << name << " features 0x" << std::hex << features
<< std::dec << " looks like " << ceph_release_name(rr) << std::endl;
EXPECT_LE(rr, r);
}
}
TEST(features, release_from_features) {
ASSERT_EQ(CEPH_RELEASE_JEWEL, ceph_release_from_features(575862587619852283));
ASSERT_EQ(CEPH_RELEASE_LUMINOUS,
ceph_release_from_features(1152323339925389307));
}
int main(int argc, char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 1,433 | 28.875 | 80 |
cc
|
null |
ceph-main/src/test/test_get_blkdev_props.cc
|
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "include/uuid.h"
#include "common/blkdev.h"
#define BUFSIZE 80
int main(int argc, char **argv)
{
int fd, ret;
int64_t size;
bool discard_support;
bool rotational;
char dev[BUFSIZE];
char model[BUFSIZE];
char serial[BUFSIZE];
char wholedisk[BUFSIZE];
char partition[BUFSIZE];
if (argc != 2) {
fprintf(stderr, "usage: %s <blkdev>\n", argv[0]);
return -1;
}
fd = open(argv[1], O_RDONLY);
if (fd < 0) {
perror("open");
return -1;
}
BlkDev blkdev(fd);
if ((ret = blkdev.get_size(&size)) < 0) {
fprintf(stderr, "get_size: %s\n", strerror(-ret));
return -1;
}
discard_support = blkdev.support_discard();
rotational = blkdev.is_rotational();
if ((ret = blkdev.dev(dev, BUFSIZE)) < 0) {
fprintf(stderr, "dev: %s\n", strerror(-ret));
return -1;
}
if ((ret = blkdev.partition(partition, BUFSIZE)) < 0) {
fprintf(stderr, "partition: %s\n", strerror(-ret));
return -1;
}
if ((ret = blkdev.wholedisk(wholedisk, BUFSIZE)) < 0) {
fprintf(stderr, "wholedisk: %s\n", strerror(-ret));
return -1;
}
ret = blkdev.model(model, BUFSIZE);
if (ret == -ENOENT) {
snprintf(model, BUFSIZE, "unknown");
} else if (ret < 0) {
fprintf(stderr, "model: %s\n", strerror(-ret));
return -1;
}
ret = blkdev.serial(serial, BUFSIZE);
if (ret == -ENOENT) {
snprintf(serial, BUFSIZE, "unknown");
} else if (ret < 0) {
fprintf(stderr, "serial: %s\n", strerror(-ret));
return -1;
}
fprintf(stdout, "Size:\t\t%" PRId64 "\n", size);
fprintf(stdout, "Discard:\t%s\n",
discard_support ? "supported" : "not supported");
fprintf(stdout, "Rotational:\t%s\n", rotational ? "yes" : "no");
fprintf(stdout, "Dev:\t\t%s\n", dev);
fprintf(stdout, "Whole disk:\t%s\n", wholedisk);
fprintf(stdout, "Partition:\t%s\n", partition);
fprintf(stdout, "Model:\t\t%s\n", model);
fprintf(stdout, "Serial:\t\t%s\n", serial);
return 0;
}
| 2,018 | 21.433333 | 65 |
cc
|
null |
ceph-main/src/test/test_intarith.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include <climits>
#include <gtest/gtest.h>
#include "include/intarith.h"
TEST(intarith, cbits) {
ASSERT_EQ(0u, cbits(0));
ASSERT_EQ(1u, cbits(1));
ASSERT_EQ(2u, cbits(2));
ASSERT_EQ(2u, cbits(3));
ASSERT_EQ(3u, cbits(4));
ASSERT_EQ(0u, cbits(0));
ASSERT_EQ(1u, cbits(1));
ASSERT_EQ(2u, cbits(2));
ASSERT_EQ(2u, cbits(3));
ASSERT_EQ(3u, cbits(4));
ASSERT_EQ(9u, cbits(0x100));
ASSERT_EQ(32u, cbits(0xffffffff));
ASSERT_EQ(32u, cbits(0xffffffff));
ASSERT_EQ(32u, cbits(0xffffffff));
ASSERT_EQ(64u, cbits(0xffffffffffffffff));
}
TEST(intarith, p2family) {
ASSERT_EQ(1024, p2align(1200, 1024));
ASSERT_EQ(1024, p2align(1024, 1024));
ASSERT_EQ(0x1200, p2align(0x1234, 0x100));
ASSERT_EQ(0x5600, p2align(0x5600, 0x100));
ASSERT_EQ(0x34, p2phase(0x1234, 0x100));
ASSERT_EQ(0x00, p2phase(0x5600, 0x100));
ASSERT_EQ(0xcc, p2nphase(0x1234, 0x100));
ASSERT_EQ(0x00, p2nphase(0x5600, 0x100));
ASSERT_EQ(0x1300, p2roundup(0x1234, 0x100));
ASSERT_EQ(0x5600, p2roundup(0x5600, 0x100));
}
| 1,128 | 26.536585 | 70 |
cc
|
null |
ceph-main/src/test/test_ipaddr.cc
|
#include "include/ipaddr.h"
#include "common/pick_address.h"
#include "gtest/gtest.h"
#include "include/stringify.h"
#include "common/ceph_context.h"
#include <boost/smart_ptr/intrusive_ptr.hpp>
#if defined(__FreeBSD__)
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#endif
#include <arpa/inet.h>
#include <ifaddrs.h>
#ifdef _WIN32
#include <ws2tcpip.h>
#else
#include <net/if.h>
#endif
using namespace std;
static void ipv4(struct sockaddr_in *addr, const char *s) {
int err;
addr->sin_family = AF_INET;
err = inet_pton(AF_INET, s, &addr->sin_addr);
ASSERT_EQ(1, err);
}
static void ipv6(struct sockaddr_in6 *addr, const char *s) {
int err;
addr->sin6_family = AF_INET6;
err = inet_pton(AF_INET6, s, &addr->sin6_addr);
ASSERT_EQ(1, err);
}
static char eth0[] = "eth0";
static char eth1[] = "eth1";
TEST(CommonIPAddr, TestNotFound)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv4(&net, "10.11.234.56");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 24));
ASSERT_FALSE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 24));
}
TEST(CommonIPAddr, TestV4_Simple)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv4(&net, "10.11.12.42");
ASSERT_TRUE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 24));
ASSERT_FALSE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 24));
}
TEST(CommonIPAddr, TestV4_Prefix25)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv4(&a_two, "10.11.12.129");
ipv4(&net, "10.11.12.128");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 25));
ASSERT_TRUE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 25));
}
TEST(CommonIPAddr, TestV4_Prefix16)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.1.1.2");
ipv4(&a_two, "10.2.1.123");
ipv4(&net, "10.2.0.0");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 16));
ASSERT_TRUE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 16));
}
TEST(CommonIPAddr, TestV4_PrefixTooLong)
{
struct ifaddrs one;
struct sockaddr_in a_one;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv4(&a_one, "10.11.12.13");
ipv4(&net, "10.11.12.12");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 42));
}
TEST(CommonIPAddr, TestV4_PrefixZero)
{
struct ifaddrs one, two;
struct sockaddr_in6 a_one;
struct sockaddr_in a_two;
struct sockaddr_in net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv6(&a_one, "2001:1234:5678:900F::cdef");
ipv4(&a_two, "10.1.2.3");
ipv4(&net, "255.0.1.2");
ASSERT_FALSE(matches_ipv4_in_subnet(one, (struct sockaddr_in*)&net, 0));
ASSERT_TRUE(matches_ipv4_in_subnet(two, (struct sockaddr_in*)&net, 0));
}
static char lo[] = "lo";
static char lo0[] = "lo:0";
TEST(CommonIPAddr, TestV4_SkipLoopback)
{
struct ifaddrs one, two, three;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in a_three;
one.ifa_next = &two;
one.ifa_flags &= ~IFF_UP;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = lo;
two.ifa_next = &three;
two.ifa_flags = IFF_UP;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = lo0;
three.ifa_next = NULL;
three.ifa_flags = IFF_UP;
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth0;
ipv4(&a_one, "127.0.0.1");
ipv4(&a_two, "127.0.0.1");
ipv4(&a_three, "10.1.2.3");
const struct sockaddr *result = nullptr;
// we prefer the non-loopback address despite the loopback addresses
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"", "");
ASSERT_EQ(three.ifa_addr, result);
// the subnet criteria leaves us no choice but the UP loopback address
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"127.0.0.0/8", "");
ASSERT_EQ(two.ifa_addr, result);
}
TEST(CommonIPAddr, TestV6_Simple)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.11.12.13");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv6(&net, "2001:1234:5678:90ab::dead:beef");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 64));
ASSERT_TRUE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 64));
}
TEST(CommonIPAddr, TestV6_Prefix57)
{
struct ifaddrs one, two;
struct sockaddr_in6 a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 net;
memset(&net, 0, sizeof(net));
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv6(&a_one, "2001:1234:5678:900F::cdef");
ipv6(&a_two, "2001:1234:5678:90ab::cdef");
ipv6(&net, "2001:1234:5678:90ab::dead:beef");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 57));
ASSERT_TRUE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 57));
}
TEST(CommonIPAddr, TestV6_PrefixTooLong)
{
struct ifaddrs one;
struct sockaddr_in6 a_one;
struct sockaddr_in6 net;
memset(&net, 0, sizeof(net));
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv6(&a_one, "2001:1234:5678:900F::cdef");
ipv6(&net, "2001:1234:5678:900F::cdee");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 9000));
}
TEST(CommonIPAddr, TestV6_PrefixZero)
{
struct ifaddrs one, two;
struct sockaddr_in a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 net;
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = NULL;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
ipv4(&a_one, "10.2.3.4");
ipv6(&a_two, "2001:f00b::1");
ipv6(&net, "ff00::1");
ASSERT_FALSE(matches_ipv6_in_subnet(one, (struct sockaddr_in6*)&net, 0));
ASSERT_TRUE(matches_ipv6_in_subnet(two, (struct sockaddr_in6*)&net, 0));
}
TEST(CommonIPAddr, TestV6_SkipLoopback)
{
struct ifaddrs one, two, three;
struct sockaddr_in6 a_one;
struct sockaddr_in6 a_two;
struct sockaddr_in6 a_three;
one.ifa_next = &two;
one.ifa_flags &= ~IFF_UP;
ipv6(&a_one, "::1");
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = lo;
two.ifa_next = &three;
two.ifa_flags = IFF_UP;
ipv6(&a_two, "::1");
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = lo0;
three.ifa_next = NULL;
three.ifa_flags = IFF_UP;
ipv6(&a_three, "2001:1234:5678:90ab::beef");
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth0;
const struct sockaddr *result = nullptr;
// we prefer the non-loopback address despite the loopback addresses
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"", "");
ASSERT_EQ(three.ifa_addr, result);
// the subnet criteria leaves us no choice but the UP loopback address
result =
find_ip_in_subnet_list(nullptr, (struct ifaddrs*)&one,
CEPH_PICK_ADDRESS_IPV4 | CEPH_PICK_ADDRESS_IPV6,
"::1/128", "");
ASSERT_EQ(two.ifa_addr, result);
}
TEST(CommonIPAddr, ParseNetwork_Empty)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_Junk)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("foo", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_SlashNum)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("/24", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_Slash)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("/", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4Slash)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4SlashNegative)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/-3", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv4SlashJunk)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/foo", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6Slash)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6SlashNegative)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/-3", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_Bad_IPv6SlashJunk)
{
struct sockaddr_storage network;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/foo", &network, &prefix_len);
ASSERT_EQ(ok, false);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_0)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/0", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(0U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_13)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/13", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(13U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_32)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/32", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(32U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv4_42)
{
struct sockaddr_in network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("123.123.123.123/42", &net_storage, &prefix_len);
network = *(struct sockaddr_in *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(42U, prefix_len);
ASSERT_EQ(AF_INET, network.sin_family);
ASSERT_EQ(0, network.sin_port);
struct sockaddr_in want;
ipv4(&want, "123.123.123.123");
ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
}
TEST(CommonIPAddr, ParseNetwork_IPv6_0)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/0", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(0U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ParseNetwork_IPv6_67)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/67", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(67U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ParseNetwork_IPv6_128)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/128", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(128U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ParseNetwork_IPv6_9000)
{
struct sockaddr_in6 network;
struct sockaddr_storage net_storage;
unsigned int prefix_len;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/9000", &net_storage, &prefix_len);
network = *(struct sockaddr_in6 *) &net_storage;
ASSERT_EQ(ok, true);
ASSERT_EQ(9000U, prefix_len);
ASSERT_EQ(AF_INET6, network.sin6_family);
ASSERT_EQ(0, network.sin6_port);
struct sockaddr_in6 want;
ipv6(&want, "2001:1234:5678:90ab::dead:beef");
ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
}
TEST(CommonIPAddr, ambiguous)
{
entity_addr_t a;
bool ok;
ok = a.parse("1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_ANY, a.get_type());
ok = a.parse("any:1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_ANY, a.get_type());
ok = a.parse("v1:1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_LEGACY, a.get_type());
ok = a.parse("v2:1.2.3.4", nullptr, entity_addr_t::TYPE_ANY);
ASSERT_TRUE(ok);
ASSERT_EQ(entity_addr_t::TYPE_MSGR2, a.get_type());
}
TEST(CommonIPAddr, network_contains)
{
entity_addr_t network, addr;
unsigned int prefix;
bool ok;
ok = parse_network("2001:1234:5678:90ab::dead:beef/32", &network, &prefix);
ASSERT_TRUE(ok);
ASSERT_EQ(32U, prefix);
ok = addr.parse("2001:1234:5678:90ab::dead:beef", nullptr);
ASSERT_TRUE(ok);
ASSERT_TRUE(network_contains(network, prefix, addr));
ok = addr.parse("2001:1334:5678:90ab::dead:beef", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = addr.parse("127.0.0.1", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = parse_network("10.1.2.3/16", &network, &prefix);
ASSERT_TRUE(ok);
ASSERT_EQ(16U, prefix);
ok = addr.parse("2001:1234:5678:90ab::dead:beef", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = addr.parse("1.2.3.4", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
ok = addr.parse("10.1.22.44", nullptr);
ASSERT_TRUE(ok);
ASSERT_TRUE(network_contains(network, prefix, addr));
ok = addr.parse("10.2.22.44", nullptr);
ASSERT_TRUE(ok);
ASSERT_FALSE(network_contains(network, prefix, addr));
}
TEST(pick_address, find_ip_in_subnet_list)
{
struct ifaddrs one, two, three;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in6 a_three;
const struct sockaddr *result;
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = &three;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
three.ifa_next = NULL;
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth1;
ipv4(&a_one, "10.1.1.2");
ipv4(&a_two, "10.2.1.123");
ipv6(&a_three, "2001:1234:5678:90ab::cdef");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_OSD);
// match by network
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.1.0.0/16",
"eth0");
ASSERT_EQ(one.ifa_addr, result);
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.2.0.0/16",
"eth1");
ASSERT_EQ(two.ifa_addr, result);
// match by eth name
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.0.0.0/8",
"eth0");
ASSERT_EQ(one.ifa_addr, result);
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV4,
"10.0.0.0/8",
"eth1");
ASSERT_EQ(two.ifa_addr, result);
result = find_ip_in_subnet_list(
cct.get(),
&one,
CEPH_PICK_ADDRESS_IPV6,
"2001::/16",
"eth1");
ASSERT_EQ(three.ifa_addr, result);
}
TEST(pick_address, filtering)
{
struct ifaddrs one, two, three;
struct sockaddr_in a_one;
struct sockaddr_in a_two;
struct sockaddr_in6 a_three;
one.ifa_next = &two;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
two.ifa_next = &three;
two.ifa_addr = (struct sockaddr*)&a_two;
two.ifa_name = eth1;
three.ifa_next = NULL;
three.ifa_addr = (struct sockaddr*)&a_three;
three.ifa_name = eth1;
ipv4(&a_one, "10.1.1.2");
ipv4(&a_two, "10.2.1.123");
ipv6(&a_three, "2001:1234:5678:90ab::cdef");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_MON);
cct->_conf._clear_safe_to_start_threads(); // so we can set configs
cct->_conf.set_val("public_addr", "");
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
cct->_conf.set_val("cluster_addr", "");
cct->_conf.set_val("cluster_network", "");
cct->_conf.set_val("cluster_network_interface", "");
entity_addrvec_t av;
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:0.0.0.0:0/0"), stringify(av.v[0]));
}
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:[::]:0/0"), stringify(av.v[0]));
}
{
cct->_conf.set_val("public_network", "10.2.0.0/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:10.2.1.123:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
}
{
cct->_conf.set_val("public_network", "10.0.0.0/8");
cct->_conf.set_val("public_network_interface", "eth1");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v2:10.2.1.123:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
}
{
cct->_conf.set_val("public_network", "10.2.0.0/16");
cct->_conf.set_val("cluster_network", "10.1.0.0/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v2:10.2.1.123:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("cluster_network", "");
}
{
cct->_conf.set_val("public_network", "10.2.0.0/16");
cct->_conf.set_val("cluster_network", "10.1.0.0/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_CLUSTER |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v1:10.1.1.2:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("cluster_network", "");
}
{
cct->_conf.set_val("public_network", "2001::/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(1u, av.v.size());
ASSERT_EQ(string("v2:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[0]));
cct->_conf.set_val("public_network", "");
}
{
cct->_conf.set_val("public_network", "2001::/16 10.0.0.0/8");
cct->_conf.set_val("public_network_interface", "eth1");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v2:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v2:10.2.1.123:0/0"), stringify(av.v[1]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
}
{
cct->_conf.set_val("public_network", "2001::/16 10.0.0.0/8");
cct->_conf.set_val("public_network_interface", "eth1");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR1 |
CEPH_PICK_ADDRESS_PREFER_IPV4,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v1:10.2.1.123:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v1:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[1]));
cct->_conf.set_val("public_network", "");
cct->_conf.set_val("public_network_interface", "");
}
{
cct->_conf.set_val("public_network", "2001::/16");
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV6 |
CEPH_PICK_ADDRESS_MSGR1 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v2:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v1:[2001:1234:5678:90ab::cdef]:0/0"), stringify(av.v[1]));
cct->_conf.set_val("public_network", "");
}
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_IPV4 |
CEPH_PICK_ADDRESS_MSGR1 |
CEPH_PICK_ADDRESS_MSGR2,
&one, &av);
ASSERT_EQ(0, r);
ASSERT_EQ(2u, av.v.size());
ASSERT_EQ(string("v2:0.0.0.0:0/0"), stringify(av.v[0]));
ASSERT_EQ(string("v1:0.0.0.0:0/0"), stringify(av.v[1]));
}
}
TEST(pick_address, ipv4_ipv6_enabled)
{
struct ifaddrs one;
struct sockaddr_in a_one;
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv4(&a_one, "10.1.1.2");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_OSD);
cct->_conf._clear_safe_to_start_threads(); // so we can set configs
cct->_conf.set_val("public_addr", "");
cct->_conf.set_val("public_network", "10.1.1.0/24");
cct->_conf.set_val("public_network_interface", "");
cct->_conf.set_val("cluster_addr", "");
cct->_conf.set_val("cluster_network", "");
cct->_conf.set_val("cluster_network_interface", "");
cct->_conf.set_val("ms_bind_ipv6", "true");
entity_addrvec_t av;
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(-1, r);
}
}
TEST(pick_address, ipv4_ipv6_enabled2)
{
struct ifaddrs one;
struct sockaddr_in6 a_one;
one.ifa_next = NULL;
one.ifa_addr = (struct sockaddr*)&a_one;
one.ifa_name = eth0;
ipv6(&a_one, "2001:1234:5678:90ab::cdef");
boost::intrusive_ptr<CephContext> cct = new CephContext(CEPH_ENTITY_TYPE_OSD);
cct->_conf._clear_safe_to_start_threads(); // so we can set configs
cct->_conf.set_val("public_addr", "");
cct->_conf.set_val("public_network", "2001::/16");
cct->_conf.set_val("public_network_interface", "");
cct->_conf.set_val("cluster_addr", "");
cct->_conf.set_val("cluster_network", "");
cct->_conf.set_val("cluster_network_interface", "");
cct->_conf.set_val("ms_bind_ipv6", "true");
entity_addrvec_t av;
{
int r = pick_addresses(cct.get(),
CEPH_PICK_ADDRESS_PUBLIC |
CEPH_PICK_ADDRESS_MSGR1,
&one, &av);
ASSERT_EQ(-1, r);
}
}
| 27,288 | 26.343687 | 109 |
cc
|
null |
ceph-main/src/test/test_lost.sh
|
#!/usr/bin/env bash
set -x
#
# Test the lost object logic
#
# Includes
source "`dirname $0`/test_common.sh"
TEST_POOL=rbd
# Functions
setup() {
export CEPH_NUM_OSD=$1
vstart_config=$2
# Start ceph
./stop.sh
# set recovery start to a really long time to ensure that we don't start recovery
./vstart.sh -d -n -o "$vstart_config" || die "vstart failed"
# for exiting pools set size not greater than number of OSDs,
# so recovery from degraded ps is possible
local changed=0
for pool in `./ceph osd pool ls`; do
local size=`./ceph osd pool get ${pool} size | awk '{print $2}'`
if [ "${size}" -gt "${CEPH_NUM_OSD}" ]; then
./ceph osd pool set ${pool} size ${CEPH_NUM_OSD} --yes-i-really-mean-it
changed=1
fi
done
if [ ${changed} -eq 1 ]; then
# XXX: When a pool has degraded pgs due to size greater than number
# of OSDs, after decreasing the size the recovery still could stuck
# and requires an additional kick.
./ceph osd out 0
./ceph osd in 0
fi
poll_cmd "./ceph health" HEALTH_OK 1 30
}
recovery1_impl() {
# Write lots and lots of objects
write_objects 1 1 200 4000 $TEST_POOL
# Take down osd1
stop_osd 1
# Continue writing a lot of objects
write_objects 2 2 200 4000 $TEST_POOL
# Bring up osd1
restart_osd 1
# Finish peering.
sleep 15
# Stop osd0.
# At this point we have peered, but *NOT* recovered.
# Objects should be lost.
stop_osd 0
poll_cmd "./ceph pg debug degraded_pgs_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see degraded PGs."
poll_cmd "./ceph pg debug unfound_objects_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see unfound objects."
echo "Got unfound objects."
restart_osd 0
sleep 20
start_recovery 2
# Turn on recovery and wait for it to complete.
poll_cmd "./ceph pg debug unfound_objects_exist" FALSE 3 120
[ $? -eq 1 ] || die "Failed to recover unfound objects."
poll_cmd "./ceph pg debug degraded_pgs_exist" FALSE 3 120
[ $? -eq 1 ] || die "Recovery never finished."
}
recovery1() {
setup 2 'osd recovery delay start = 10000'
recovery1_impl
}
lost1_impl() {
local flags="$@"
local lost_action=delete
local pgs_unfound pg
if is_set revert_lost $flags; then
lost_action=revert
fi
# Write lots and lots of objects
write_objects 1 1 20 8000 $TEST_POOL
# Take down osd1
stop_osd 1
# Continue writing a lot of objects
write_objects 2 2 20 8000 $TEST_POOL
# Bring up osd1
restart_osd 1
# Finish peering.
sleep 15
# Stop osd0.
# At this point we have peered, but *NOT* recovered.
# Objects should be lost.
stop_osd 0
# Since recovery can't proceed, stuff should be unfound.
poll_cmd "./ceph pg debug unfound_objects_exist" TRUE 3 120
[ $? -eq 1 ] || die "Failed to see unfound objects."
pgs_unfound=`./ceph health detail |awk '$1 = "pg" && /[0-9] unfound$/ {print $2}'`
[ -n "$pgs_unfound" ] || die "no pg with unfound objects"
for pg in $pgs_unfound; do
./ceph pg $pg mark_unfound_lost revert &&
die "mark_unfound_lost unexpectedly succeeded for pg $pg"
done
if ! is_set mark_osd_lost $flags && ! is_set rm_osd $flags; then
return
fi
if is_set try_to_fetch_unfound $flags; then
# Ask for an object while it's still unfound, and
# verify we get woken to an error when it's declared lost.
echo "trying to get one of the unfound objects"
(
./rados -c ./ceph.conf -p $TEST_POOL get obj02 $TEMPDIR/obj02 &&\
die "expected radostool error"
) &
fi
if is_set mark_osd_lost $flags; then
./ceph osd lost 0 --yes-i-really-mean-it
fi
if is_set rm_osd $flags; then
./ceph osd rm 0
fi
if ! is_set auto_mark_unfound_lost $flags; then
for pg in $pgs_unfound; do
./ceph pg $pg mark_unfound_lost ${lost_action} ||
die "mark_unfound_lost failed for pg $pg"
done
fi
start_recovery 2
# Unfound objects go away and are turned into lost objects.
poll_cmd "./ceph pg debug unfound_objects_exist" FALSE 3 120
[ $? -eq 1 ] || die "Unfound objects didn't go away."
for pg in `ceph pg ls | awk '/^[0-9]/ {print $1}'`; do
./ceph pg $pg mark_unfound_lost revert 2>&1 |
grep 'pg has no unfound objects' ||
die "pg $pg has unfound objects"
done
# Reading from a lost object gives back an error code.
# TODO: check error code
./rados -c ./ceph.conf -p $TEST_POOL get obj01 $TEMPDIR/obj01
if [ lost_action = delete -a $? -eq 0 ]; then
die "expected radostool error"
elif [ lost_action = revert -a $? -ne 0 ]; then
die "unexpected radostool error"
fi
if is_set try_to_fetch_unfound $flags; then
echo "waiting for the try_to_fetch_unfound \
radostool instance to finish"
wait
fi
}
lost1() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost revert_lost
}
lost2() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost try_to_fetch_unfound
}
lost3() {
setup 2 'osd recovery delay start = 10000'
lost1_impl rm_osd
}
lost4() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost rm_osd
}
lost5() {
setup 2 'osd recovery delay start = 10000'
lost1_impl mark_osd_lost auto_mark_unfound_lost
}
all_osds_die_impl() {
poll_cmd "./ceph osd stat" '3 up, 3 in' 20 240
[ $? -eq 1 ] || die "didn't start 3 osds"
stop_osd 0
stop_osd 1
stop_osd 2
# wait for the MOSDPGStat timeout
poll_cmd "./ceph osd stat" '0 up' 20 240
[ $? -eq 1 ] || die "all osds weren't marked as down"
}
all_osds_die() {
setup 3 'osd mon report interval = 3
mon osd report timeout = 60'
all_osds_die_impl
}
run() {
recovery1 || die "test failed"
lost1 || die "test failed"
# XXX: try_to_fetch_unfound test currently hangs on "waiting for the
# try_to_fetch_unfound radostool instance to finish"
#lost2 || die "test failed"
lost3 || die "test failed"
lost4 || die "test failed"
# XXX: automatically marking lost is not implemented
#lost5 || die "test failed"
all_osds_die || die "test failed"
}
if [ -z "$@" ]; then
run
echo OK
exit 0
fi
$@
| 6,419 | 23.883721 | 89 |
sh
|
null |
ceph-main/src/test/test_mempool.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2016 Western Digital Corporation
*
* Author: Allen Samuels <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include "global/global_init.h"
#include "common/ceph_argparse.h"
#include "global/global_context.h"
#include "gtest/gtest.h"
#include "include/btree_map.h"
#include "include/mempool.h"
using namespace std;
void check_usage(mempool::pool_index_t ix)
{
mempool::pool_t *pool = &mempool::get_pool(ix);
mempool::stats_t total;
map<std::string,mempool::stats_t> m;
pool->get_stats(&total, &m);
size_t usage = pool->allocated_bytes();
size_t sum = 0;
for (auto& p : m) {
sum += p.second.bytes;
}
if (sum != usage) {
ceph::TableFormatter jf;
pool->dump(&jf);
jf.flush(std::cout);
}
EXPECT_EQ(sum, usage);
}
template<typename A, typename B>
void eq_elements(const A& a, const B& b)
{
auto lhs = a.begin();
auto rhs = b.begin();
while (lhs != a.end()) {
EXPECT_EQ(*lhs,*rhs);
lhs++;
rhs++;
}
EXPECT_EQ(rhs,b.end());
}
template<typename A, typename B>
void eq_pairs(const A& a, const B& b)
{
auto lhs = a.begin();
auto rhs = b.begin();
while (lhs != a.end()) {
EXPECT_EQ(lhs->first,rhs->first);
EXPECT_EQ(lhs->second,rhs->second);
lhs++;
rhs++;
}
EXPECT_EQ(rhs,b.end());
}
#define MAKE_INSERTER(inserter) \
template<typename A,typename B> \
void do_##inserter(A& a, B& b, int count, int base) { \
for (int i = 0; i < count; ++i) { \
a.inserter(base + i); \
b.inserter(base + i); \
} \
}
MAKE_INSERTER(push_back);
MAKE_INSERTER(insert);
template<typename A,typename B>
void do_insert_key(A& a, B& b, int count, int base)
{
for (int i = 0; i < count; ++i) {
a.insert(make_pair(base+i,base+i));
b.insert(make_pair(base+i,base+i));
check_usage(mempool::osd::id);
}
}
TEST(mempool, vector_context)
{
check_usage(mempool::osd::id);
EXPECT_EQ(mempool::osd::allocated_bytes(), 0u);
EXPECT_EQ(mempool::osd::allocated_items(), 0u);
for (unsigned i = 0; i < 10; ++i) {
vector<int> a;
mempool::osd::vector<int> b,c;
eq_elements(a,b);
do_push_back(a,b,i,i);
eq_elements(a,b);
check_usage(mempool::osd::id);
mempool::stats_t total;
map<std::string,mempool::stats_t> by_type;
mempool::get_pool(mempool::osd::id).get_stats(&total, &by_type);
EXPECT_GE(mempool::osd::allocated_bytes(), i * 4u);
EXPECT_GE(mempool::osd::allocated_items(), i);
c.swap(b);
eq_elements(a,c);
check_usage(mempool::osd::id);
a.clear();
b.clear();
c.clear();
}
}
TEST(mempool, list_context)
{
for (unsigned i = 1; i < 10; ++i) {
list<int> a;
mempool::osd::list<int> b,c;
eq_elements(a,b);
do_push_back(a,b,i,i);
eq_elements(a,b);
c.swap(b);
eq_elements(a,c);
a.erase(a.begin());
c.erase(c.begin());
eq_elements(a,c);
a.clear();
b.clear();
c.clear();
do_push_back(a,b,i,i);
c.splice(c.begin(),b,b.begin(),b.end());
mempool::stats_t total;
map<std::string,mempool::stats_t> by_type;
mempool::get_pool(mempool::osd::id).get_stats(&total, &by_type);
EXPECT_GE(mempool::osd::allocated_bytes(), i * 4u);
EXPECT_EQ(mempool::osd::allocated_items(), i);
eq_elements(a,c);
check_usage(mempool::osd::id);
}
}
TEST(mempool, set_context)
{
for (int i = 0; i < 10; ++i) {
set<int> a;
mempool::osd::set<int> b;
do_insert(a,b,i,i);
eq_elements(a,b);
check_usage(mempool::osd::id);
}
for (int i = 1; i < 10; ++i) {
set<int> a;
mempool::osd::set<int> b;
do_insert(a,b,i,0);
EXPECT_NE(a.find(i/2),a.end());
EXPECT_NE(b.find(i/2),b.end());
a.erase(a.find(i/2));
b.erase(b.find(i/2));
eq_elements(a,b);
check_usage(mempool::osd::id);
}
}
struct obj {
MEMPOOL_CLASS_HELPERS();
int a;
int b;
obj() : a(1), b(1) {}
explicit obj(int _a) : a(_a), b(2) {}
obj(int _a,int _b) : a(_a), b(_b) {}
friend inline bool operator<(const obj& l, const obj& r) {
return l.a < r.a;
}
};
MEMPOOL_DEFINE_OBJECT_FACTORY(obj, obj, osdmap);
TEST(mempool, test_factory)
{
obj *o1 = new obj();
obj *o2 = new obj(10);
obj *o3 = new obj(20,30);
check_usage(mempool::osdmap::id);
EXPECT_NE(o1,nullptr);
EXPECT_EQ(o1->a,1);
EXPECT_EQ(o1->b,1);
EXPECT_EQ(o2->a,10);
EXPECT_EQ(o2->b,2);
EXPECT_EQ(o3->a,20);
EXPECT_EQ(o3->b,30);
delete o1;
delete o2;
delete o3;
check_usage(mempool::osdmap::id);
}
TEST(mempool, vector)
{
{
mempool::osd::vector<int> v;
v.push_back(1);
v.push_back(2);
}
{
mempool::osdmap::vector<obj> v;
v.push_back(obj());
v.push_back(obj(1));
}
}
TEST(mempool, set)
{
mempool::osd::set<int> set_int;
set_int.insert(1);
set_int.insert(2);
mempool::osdmap::set<obj> set_obj;
set_obj.insert(obj());
set_obj.insert(obj(1));
set_obj.insert(obj(1, 2));
}
TEST(mempool, map)
{
{
mempool::osd::map<int,int> v;
v[1] = 2;
v[3] = 4;
}
{
mempool::osdmap::map<int,obj> v;
v[1] = obj();
v[2] = obj(2);
v[3] = obj(2, 3);
}
}
TEST(mempool, list)
{
{
mempool::osd::list<int> v;
v.push_back(1);
v.push_back(2);
}
{
mempool::osdmap::list<obj> v;
v.push_back(obj());
v.push_back(obj(1));
}
}
TEST(mempool, dump)
{
ostringstream ostr;
Formatter* f = Formatter::create("xml-pretty", "xml-pretty", "xml-pretty");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
ostr.str("");
f = Formatter::create("html-pretty", "html-pretty", "html-pretty");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
ostr.str("");
f = Formatter::create("table", "table", "table");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
ostr.str("");
f = Formatter::create("json-pretty", "json-pretty", "json-pretty");
mempool::dump(f);
f->flush(ostr);
delete f;
ASSERT_NE(ostr.str().find(mempool::get_pool_name((mempool::pool_index_t)0)),
std::string::npos);
}
TEST(mempool, unordered_map)
{
mempool::osdmap::unordered_map<int,obj> h;
h[1] = obj();
h[2] = obj(1);
}
TEST(mempool, string_test)
{
mempool::osdmap::string s;
s.reserve(100);
EXPECT_GE(mempool::osdmap::allocated_items(), s.capacity() + 1u); // +1 for zero-byte termination :
for (size_t i = 0; i < 10; ++i) {
s += '1';
s.append(s);
EXPECT_GE(mempool::osdmap::allocated_items(), s.capacity() + 1u);
}
}
TEST(mempool, bufferlist)
{
bufferlist bl;
int len = 1048576;
size_t before = mempool::buffer_anon::allocated_bytes();
cout << "before " << before << std::endl;
bl.append(buffer::create_aligned(len, 4096));
size_t after = mempool::buffer_anon::allocated_bytes();
cout << "after " << after << std::endl;
ASSERT_GE(after, before + len);
}
TEST(mempool, bufferlist_reassign)
{
bufferlist bl;
size_t items_before = mempool::buffer_anon::allocated_items();
size_t bytes_before = mempool::buffer_anon::allocated_bytes();
bl.append("fooo");
ASSERT_EQ(items_before + 1, mempool::buffer_anon::allocated_items());
ASSERT_LT(bytes_before, mempool::buffer_anon::allocated_bytes());
// move existing bl
bl.reassign_to_mempool(mempool::mempool_osd);
ASSERT_EQ(items_before, mempool::buffer_anon::allocated_items());
ASSERT_EQ(bytes_before, mempool::buffer_anon::allocated_bytes());
// additional appends should go to the same pool
items_before = mempool::osd::allocated_items();
bytes_before = mempool::osd::allocated_bytes();
cout << "anon b " << mempool::buffer_anon::allocated_bytes() << std::endl;
for (unsigned i = 0; i < 1000; ++i) {
bl.append("asdfddddddddddddddddddddddasfdasdfasdfasdfasdfasdf");
}
cout << "anon a " << mempool::buffer_anon::allocated_bytes() << std::endl;
ASSERT_LT(items_before, mempool::osd::allocated_items());
ASSERT_LT(bytes_before, mempool::osd::allocated_bytes());
// try_.. won't
items_before = mempool::osd::allocated_items();
bytes_before = mempool::osd::allocated_bytes();
bl.try_assign_to_mempool(mempool::mempool_bloom_filter);
ASSERT_EQ(items_before, mempool::osd::allocated_items());
ASSERT_EQ(bytes_before, mempool::osd::allocated_bytes());
}
TEST(mempool, bufferlist_c_str)
{
bufferlist bl;
int len = 1048576;
size_t before = mempool::osd::allocated_bytes();
bl.append(buffer::create_aligned(len, 4096));
bl.append(buffer::create_aligned(len, 4096));
bl.reassign_to_mempool(mempool::mempool_osd);
size_t after = mempool::osd::allocated_bytes();
ASSERT_GE(after, before + len * 2);
bl.c_str();
size_t after_c_str = mempool::osd::allocated_bytes();
ASSERT_EQ(after, after_c_str);
}
TEST(mempool, btree_map_test)
{
typedef mempool::pool_allocator<mempool::mempool_osd,
pair<const uint64_t,uint64_t>> allocator_t;
typedef btree::btree_map<uint64_t,uint64_t,std::less<uint64_t>,allocator_t> btree_t;
{
btree_t btree;
ASSERT_EQ(0, mempool::osd::allocated_items());
ASSERT_EQ(0, mempool::osd::allocated_bytes());
for (size_t i = 0; i < 1000; ++i) {
btree[rand()] = rand();
}
ASSERT_LT(0, mempool::osd::allocated_items());
ASSERT_LT(0, mempool::osd::allocated_bytes());
}
ASSERT_EQ(0, mempool::osd::allocated_items());
ASSERT_EQ(0, mempool::osd::allocated_bytes());
}
TEST(mempool, check_shard_select)
{
const size_t samples = mempool::num_shards * 100;
std::atomic_int shards[mempool::num_shards] = {0};
std::vector<std::thread> workers;
for (size_t i = 0; i < samples; i++) {
workers.push_back(
std::thread([&](){
size_t i = mempool::pool_t::pick_a_shard_int();
shards[i]++;
}));
}
for (auto& t:workers) {
t.join();
}
workers.clear();
size_t missed = 0;
for (size_t i = 0; i < mempool::num_shards; i++) {
if (shards[i] == 0) {
missed++;
}
}
// If more than half of the shards did not get anything,
// the distribution is bad enough to deserve a failure.
EXPECT_LT(missed, mempool::num_shards / 2);
}
int main(int argc, char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
// enable debug mode for the tests
mempool::set_debug_mode(true);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
/*
* Local Variables:
* compile-command: "cd ../../build ; make -j4 &&
* make unittest_mempool &&
* valgrind --tool=memcheck ./unittest_mempool --gtest_filter=*.*"
* End:
*/
| 11,258 | 23.422993 | 101 |
cc
|
null |
ceph-main/src/test/test_missing_unfound.sh
|
#!/bin/sh
CEPH_NUM_OSD=3 ./vstart.sh -d -n -x -o 'osd recovery max active = 1'
TEST_POOL=rbd
./ceph -c ./ceph.conf osd pool set $TEST_POOL size 3
sleep 20
./init-ceph stop osd.1
./ceph osd down 1 # faster
for f in `seq 1 100`
do
./rados -c ./ceph.conf -p $TEST_POOL put test_$f /etc/passwd
done
# zap some objects on both replicas
#rm dev/osd[02]/current/*/test_40*
# some on only one
rm dev/osd0/current/*/test_*
#rm dev/osd2/current/*/test_6*
# ...and see how we fare!
./init-ceph start osd.1
| 512 | 16.1 | 68 |
sh
|
null |
ceph-main/src/test/test_mutate.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2011 New Dream Network
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
/*
* Test Ioctx::operate
*/
#include "common/ceph_argparse.h"
#include "common/debug.h"
#include "common/config.h"
#include "global/global_init.h"
#include "include/rados/librados.hpp"
#include "include/types.h"
#include <errno.h>
#include <iostream>
#include <string>
using std::cerr;
using std::string;
using namespace librados;
static void usage(void)
{
cerr << "--oid set object id to 'operate' on" << std::endl;
cerr << "--pool set pool to 'operate' on" << std::endl;
}
int main(int argc, const char **argv)
{
auto args = argv_to_vec(argc, argv);
auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(g_ceph_context);
string val;
string oid("ceph_test_object");
string pool_name("test_pool");
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
}
else if (ceph_argparse_witharg(args, i, &val, "--oid", "-o", (char*)NULL)) {
oid = val;
}
else if (ceph_argparse_witharg(args, i, &val, "--pool", "-p", (char*)NULL)) {
pool_name = val;
}
else {
cerr << "unknown command line option: " << *i << std::endl;
cerr << std::endl;
usage();
return 2;
}
}
Rados rados;
if (rados.init_with_context(g_ceph_context) < 0) {
cerr << "couldn't initialize rados!" << std::endl;
return 1;
}
if (rados.conf_read_file(NULL) < 0) {
cerr << "failed to read rados configuration file!" << std::endl;
return 1;
}
if (rados.connect() < 0) {
cerr << "couldn't connect to cluster!" << std::endl;
return 1;
}
int ret = 0;
librados::ObjectWriteOperation o;
IoCtx ioctx;
if (rados.pool_lookup(pool_name.c_str()) <= 0) {
ret = rados.pool_create(pool_name.c_str());
if (ret) {
cerr << "failed to create pool named '" << pool_name
<< "': error " << ret << std::endl;
return 1;
}
}
ret = rados.ioctx_create(pool_name.c_str(), ioctx);
if (ret) {
cerr << "failed to create ioctx for pool '" << pool_name
<< "': error " << ret << std::endl;
return 1;
}
ioctx.application_enable("rados", true);
librados::ObjectWriteOperation op;
op.create(true);
ret = ioctx.operate(oid, &op);
if (ret) {
cerr << "ioctx.operate failed: ret = " << ret << std::endl;
return 1;
}
return 0;
}
| 2,870 | 24.40708 | 81 |
cc
|
null |
ceph-main/src/test/test_objectstore_memstore.sh
|
#!/bin/sh -ex
rm -rf memstore.test_temp_dir
ceph_test_objectstore --gtest_filter=\*/0
echo OK
| 96 | 12.857143 | 41 |
sh
|
null |
ceph-main/src/test/test_pageset.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#include "gtest/gtest.h"
#include "os/memstore/PageSet.h"
template <typename T>
bool is_aligned(T* ptr) {
const auto align_mask = alignof(T) - 1;
return (reinterpret_cast<uintptr_t>(ptr) & align_mask) == 0;
}
TEST(PageSet, AllocAligned)
{
PageSet pages(1);
PageSet::page_vector range;
pages.alloc_range(0, 4, range);
ASSERT_EQ(4u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(1u, range[1]->offset);
ASSERT_EQ(2u, range[2]->offset);
ASSERT_EQ(3u, range[3]->offset);
// verify that the Page pointers are properly aligned
ASSERT_TRUE(is_aligned(range[0].get()));
ASSERT_TRUE(is_aligned(range[1].get()));
ASSERT_TRUE(is_aligned(range[2].get()));
ASSERT_TRUE(is_aligned(range[3].get()));
}
TEST(PageSet, AllocUnaligned)
{
PageSet pages(2);
PageSet::page_vector range;
// front of first page
pages.alloc_range(0, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page
pages.alloc_range(1, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page and front of second
pages.alloc_range(1, 2, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page and all of second
pages.alloc_range(1, 3, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page, all of second, and front of third
pages.alloc_range(1, 4, range);
ASSERT_EQ(3u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
ASSERT_EQ(4u, range[2]->offset);
}
TEST(PageSet, GetAligned)
{
// allocate 4 pages
PageSet pages(1);
PageSet::page_vector range;
pages.alloc_range(0, 4, range);
range.clear();
// get first page
pages.get_range(0, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// get second and third pages
pages.get_range(1, 2, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(1u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// get all four pages
pages.get_range(0, 4, range);
ASSERT_EQ(4u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(1u, range[1]->offset);
ASSERT_EQ(2u, range[2]->offset);
ASSERT_EQ(3u, range[3]->offset);
range.clear();
}
TEST(PageSet, GetUnaligned)
{
// allocate 3 pages
PageSet pages(2);
PageSet::page_vector range;
pages.alloc_range(0, 6, range);
range.clear();
// front of first page
pages.get_range(0, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page
pages.get_range(1, 1, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(0u, range[0]->offset);
range.clear();
// back of first page and front of second
pages.get_range(1, 2, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page and all of second
pages.get_range(1, 3, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// back of first page, all of second, and front of third
pages.get_range(1, 4, range);
ASSERT_EQ(3u, range.size());
ASSERT_EQ(0u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
ASSERT_EQ(4u, range[2]->offset);
range.clear();
// back of third page with nothing beyond
pages.get_range(5, 999, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(4u, range[0]->offset);
range.clear();
}
TEST(PageSet, GetHoles)
{
// allocate pages at offsets 1, 2, 5, and 7
PageSet pages(1);
PageSet::page_vector range;
for (uint64_t i : {1, 2, 5, 7})
pages.alloc_range(i, 1, range);
range.clear();
// nothing at offset 0, page at offset 1
pages.get_range(0, 2, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(1u, range[0]->offset);
range.clear();
// nothing at offset 0, pages at offset 1 and 2, nothing at offset 3
pages.get_range(0, 4, range);
ASSERT_EQ(2u, range.size());
ASSERT_EQ(1u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
range.clear();
// page at offset 2, nothing at offset 3 or 4
pages.get_range(2, 3, range);
ASSERT_EQ(1u, range.size());
ASSERT_EQ(2u, range[0]->offset);
range.clear();
// get the full range
pages.get_range(0, 999, range);
ASSERT_EQ(4u, range.size());
ASSERT_EQ(1u, range[0]->offset);
ASSERT_EQ(2u, range[1]->offset);
ASSERT_EQ(5u, range[2]->offset);
ASSERT_EQ(7u, range[3]->offset);
range.clear();
}
TEST(PageSet, FreeAligned)
{
// allocate 4 pages
PageSet pages(1);
PageSet::page_vector range;
pages.alloc_range(0, 4, range);
range.clear();
// get the full range
pages.get_range(0, 4, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free after offset 4 has no effect
pages.free_pages_after(4);
pages.get_range(0, 4, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free page 4
pages.free_pages_after(3);
pages.get_range(0, 4, range);
ASSERT_EQ(3u, range.size());
range.clear();
// free pages 2 and 3
pages.free_pages_after(1);
pages.get_range(0, 4, range);
ASSERT_EQ(1u, range.size());
range.clear();
}
TEST(PageSet, FreeUnaligned)
{
// allocate 4 pages
PageSet pages(2);
PageSet::page_vector range;
pages.alloc_range(0, 8, range);
range.clear();
// get the full range
pages.get_range(0, 8, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free after offset 7 has no effect
pages.free_pages_after(7);
pages.get_range(0, 8, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free page 4
pages.free_pages_after(5);
pages.get_range(0, 8, range);
ASSERT_EQ(3u, range.size());
range.clear();
// free pages 2 and 3
pages.free_pages_after(1);
pages.get_range(0, 8, range);
ASSERT_EQ(1u, range.size());
range.clear();
}
TEST(PageSet, FreeHoles)
{
// allocate pages at offsets 1, 2, 5, and 7
PageSet pages(1);
PageSet::page_vector range;
for (uint64_t i : {1, 2, 5, 7})
pages.alloc_range(i, 1, range);
range.clear();
// get the full range
pages.get_range(0, 8, range);
ASSERT_EQ(4u, range.size());
range.clear();
// free page 7
pages.free_pages_after(6);
pages.get_range(0, 8, range);
ASSERT_EQ(3u, range.size());
range.clear();
// free page 5
pages.free_pages_after(3);
pages.get_range(0, 8, range);
ASSERT_EQ(2u, range.size());
range.clear();
// free pages 1 and 2
pages.free_pages_after(0);
pages.get_range(0, 8, range);
ASSERT_EQ(0u, range.size());
}
| 6,808 | 22.975352 | 70 |
cc
|
null |
ceph-main/src/test/test_pidfile.sh
|
#!/usr/bin/env bash
#
# test pidfile here
#
# Includes
source $(dirname $0)/detect-build-env-vars.sh
source $CEPH_ROOT/qa/standalone/ceph-helpers.sh
function run() {
local dir=$1
shift
export CEPH_MON="127.0.0.1:7124" # git grep '\<7124\>' : there must be only one
export CEPH_ARGS
CEPH_ARGS+="--fsid=$(uuidgen) --auth-supported=none "
CEPH_ARGS+="--mon-host=$CEPH_MON "
local funcs=${@:-$(set | sed -n -e 's/^\(TEST_[0-9a-z_]*\) .*/\1/p')}
for func in $funcs ; do
$func $dir || return 1
done
}
function TEST_without_pidfile() {
local dir=$1
setup $dir
local data=$dir/osd1
local id=1
ceph-mon \
--id $id \
--mkfs \
--mon-data=$data \
--run-dir=$dir || return 1
expect_failure $dir "ignore empty --pid-file" ceph-mon \
-f \
--log-to-stderr \
--log_flush_on_exit \
--pid-file= \
--id $id \
--mon-data=$data \
--run-dir=$dir || return 1
teardown $dir
}
function TEST_pidfile() {
local dir=$1
setup $dir
# no daemon can use a pidfile that is owned by another daemon
run_mon $dir a || return 1
sleep 5
run_mon $dir a --log-to-stderr -f 2>&1 | grep "failed to lock pidfile" || return 1
run_osd $dir 0 || return 1
sleep 5
activate_osd $dir 0 --log-to-stderr -f 2>&1 | grep "failed to lock pidfile" || return 1
# when a daemon shutdown, it will not unlink a path different from
# the one it owns
mv $dir/osd.0.pid $dir/osd.0.pid.old || return 1
cp $dir/osd.0.pid.old $dir/osd.0.pid || return 1
kill_daemons $dir TERM osd.0 || return 1
test -f $dir/osd.0.pid || return 1
# when a daemon starts, it re-uses the pid file if no other daemon
# has it locked
run_osd $dir 0 || return 1
! cmp $dir/osd.0.pid $dir/osd.0.pid.old || return 1
# if the pid in the file is different from the pid of the daemon
# the file is not removed because it is assumed to be owned by
# another daemon
mkdir $dir/old
cp $dir/osd.0.pid $dir/old/osd.0.pid # so that kill_daemon finds the pid
echo 123 > $dir/osd.0.pid
kill_daemons $dir/old TERM osd.0 || return 1
test -f $dir/osd.0.pid || return 1
# when the daemon shutdown, it removes its own pid file
test -f $dir/mon.a.pid || return 1
kill_daemons $dir TERM mon.a || return 1
! test -f $dir/mon.a.pid || return 1
teardown $dir || return 1
}
main pidfile "$@"
| 2,479 | 26.252747 | 91 |
sh
|
null |
ceph-main/src/test/test_pools.sh
|
#!/usr/bin/env bash
set -x
#
# Test pools
#
# Includes
source "`dirname $0`/test_common.sh"
# Functions
setup() {
export CEPH_NUM_OSD=$1
# Start ceph
./stop.sh
./vstart.sh -d -n || die "vstart failed"
}
test629_impl() {
# create the pool
./ceph -c ./ceph.conf osd pool create foo 8 || die "pool create failed"
# Write lots and lots of objects
write_objects 1 1 10 1000000 foo
# Take down first osd
stop_osd 0
# Now degraded PGs should exist
poll_cmd "./ceph pg debug degraded_pgs_exist" TRUE 3 120
# delete the pool
./ceph -c ./ceph.conf osd pool rm foo foo --yes-i-really-really-mean-it || die "pool rm failed"
# make sure the system is stable
sleep 10
}
test629(){
setup 3
test629_impl
}
run() {
test629 || die "test failed"
}
$@
| 898 | 16.627451 | 103 |
sh
|
null |
ceph-main/src/test/test_rados_tool.sh
|
../../qa/workunits/rados/test_rados_tool.sh
| 43 | 43 | 43 |
sh
|
null |
ceph-main/src/test/test_random_string.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2019 Red Hat
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/random_string.h"
#include "common/ceph_context.h"
#include "global/global_context.h"
#include <gtest/gtest.h>
inline bool is_alphanumeric_lower(char c) {
return std::islower(c) || std::isdigit(c);
}
inline bool is_alphanumeric_upper(char c) {
return std::isupper(c) || std::isdigit(c);
}
inline bool is_alphanumeric_plain(char c) {
return std::islower(c) || std::isupper(c) || std::isdigit(c);
}
inline bool is_alphanumeric_no_underscore(char c) {
return is_alphanumeric_plain(c) || c == '-' || c == '.';
}
inline bool is_alphanumeric(char c) {
return is_alphanumeric_plain(c) || c == '-' || c == '_';
}
inline bool is_base64(char c) {
return is_alphanumeric_plain(c) || c == '+' || c == '/';
}
TEST(RandomString, base64)
{
char arr[65] = {};
ASSERT_EQ(0, gen_rand_base64(g_ceph_context, arr, sizeof(arr)));
EXPECT_EQ(0, arr[64]); // must be null terminated
EXPECT_TRUE(std::all_of(arr, arr + 64, is_base64));
}
TEST(RandomString, alphanumeric)
{
char arr[65] = {};
gen_rand_alphanumeric(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric));
}
TEST(RandomString, alphanumeric_string)
{
std::string str = gen_rand_alphanumeric(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric));
}
TEST(RandomString, alphanumeric_lower)
{
char arr[65] = {};
gen_rand_alphanumeric_lower(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_lower));
}
TEST(RandomString, alphanumeric_lower_string)
{
std::string str = gen_rand_alphanumeric_lower(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_lower));
}
TEST(RandomString, alphanumeric_upper)
{
char arr[65] = {};
gen_rand_alphanumeric_upper(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_upper));
}
TEST(RandomString, alphanumeric_upper_string)
{
std::string str = gen_rand_alphanumeric_upper(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_upper));
}
TEST(RandomString, alphanumeric_no_underscore)
{
char arr[65] = {};
gen_rand_alphanumeric_no_underscore(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_no_underscore));
}
TEST(RandomString, alphanumeric_no_underscore_string)
{
std::string str = gen_rand_alphanumeric_no_underscore(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_no_underscore));
}
TEST(RandomString, alphanumeric_plain)
{
char arr[65] = {};
gen_rand_alphanumeric_plain(g_ceph_context, arr, sizeof(arr));
EXPECT_EQ(0, arr[64]);
EXPECT_TRUE(std::all_of(arr, arr + 64, is_alphanumeric_plain));
}
TEST(RandomString, alphanumeric_plain_string)
{
std::string str = gen_rand_alphanumeric_plain(g_ceph_context, 64);
EXPECT_EQ(64, str.size());
EXPECT_TRUE(std::all_of(str.begin(), str.end(), is_alphanumeric_plain));
}
| 3,587 | 28.652893 | 82 |
cc
|
null |
ceph-main/src/test/test_rbd_replay.cc
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2014 Adam Crume <[email protected]>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#include "common/escape.h"
#include "gtest/gtest.h"
#include <stdint.h>
#include <boost/foreach.hpp>
#include <cstdarg>
#include "rbd_replay/ImageNameMap.hpp"
#include "rbd_replay/ios.hpp"
#include "rbd_replay/rbd_loc.hpp"
namespace rbd_replay {
std::ostream& operator<<(std::ostream& o, const rbd_loc& name) {
return o << "('" << name.pool << "', '" << name.image << "', '" << name.snap << "')";
}
}
using namespace rbd_replay;
static void add_mapping(ImageNameMap *map, std::string mapping_string) {
ImageNameMap::Mapping mapping;
if (!map->parse_mapping(mapping_string, &mapping)) {
ASSERT_TRUE(false) << "Failed to parse mapping string '" << mapping_string << "'";
}
map->add_mapping(mapping);
}
TEST(RBDReplay, ImageNameMap) {
ImageNameMap m;
add_mapping(&m, "x@y=y@x");
add_mapping(&m, "a\\=b@c=h@i");
add_mapping(&m, "a@b\\=c=j@k");
add_mapping(&m, "a\\@b@c=d@e");
add_mapping(&m, "a@b\\@c=f@g");
add_mapping(&m, "image@snap_1=image_1");
ImageNameMap::Mapping mapping;
EXPECT_FALSE(m.parse_mapping("bad=@@@", &mapping));
EXPECT_FALSE(m.parse_mapping("bad==stuff", &mapping));
EXPECT_EQ(rbd_loc("", "y", "x"), m.map(rbd_loc("", "x", "y")));
EXPECT_EQ(rbd_loc("", "h", "i"), m.map(rbd_loc("", "a=b", "c")));
EXPECT_EQ(rbd_loc("", "j", "k"), m.map(rbd_loc("", "a", "b=c")));
EXPECT_EQ(rbd_loc("", "d", "e"), m.map(rbd_loc("", "a@b", "c")));
EXPECT_EQ(rbd_loc("", "f", "g"), m.map(rbd_loc("", "a", "b@c")));
EXPECT_EQ(rbd_loc("", "image_1", ""), m.map(rbd_loc("", "image", "snap_1")));
}
TEST(RBDReplay, rbd_loc_str) {
EXPECT_EQ("", rbd_loc("", "", "").str());
EXPECT_EQ("a/", rbd_loc("a", "", "").str());
EXPECT_EQ("b", rbd_loc("", "b", "").str());
EXPECT_EQ("a/b", rbd_loc("a", "b", "").str());
EXPECT_EQ("@c", rbd_loc("", "", "c").str());
EXPECT_EQ("a/@c", rbd_loc("a", "", "c").str());
EXPECT_EQ("b@c", rbd_loc("", "b", "c").str());
EXPECT_EQ("a/b@c", rbd_loc("a", "b", "c").str());
EXPECT_EQ("a\\@x/b\\@y@c\\@z", rbd_loc("a@x", "b@y", "c@z").str());
EXPECT_EQ("a\\/x/b\\/y@c\\/z", rbd_loc("a/x", "b/y", "c/z").str());
EXPECT_EQ("a\\\\x/b\\\\y@c\\\\z", rbd_loc("a\\x", "b\\y", "c\\z").str());
}
TEST(RBDReplay, rbd_loc_parse) {
rbd_loc m("x", "y", "z");
EXPECT_TRUE(m.parse(""));
EXPECT_EQ("", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("a/"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("b"));
EXPECT_EQ("", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("a/b"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("", m.snap);
EXPECT_TRUE(m.parse("@c"));
EXPECT_EQ("", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("a/@c"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("b@c"));
EXPECT_EQ("", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("a/b@c"));
EXPECT_EQ("a", m.pool);
EXPECT_EQ("b", m.image);
EXPECT_EQ("c", m.snap);
EXPECT_TRUE(m.parse("a\\@x/b\\@y@c\\@z"));
EXPECT_EQ("a@x", m.pool);
EXPECT_EQ("b@y", m.image);
EXPECT_EQ("c@z", m.snap);
EXPECT_TRUE(m.parse("a\\/x/b\\/y@c\\/z"));
EXPECT_EQ("a/x", m.pool);
EXPECT_EQ("b/y", m.image);
EXPECT_EQ("c/z", m.snap);
EXPECT_TRUE(m.parse("a\\\\x/b\\\\y@c\\\\z"));
EXPECT_EQ("a\\x", m.pool);
EXPECT_EQ("b\\y", m.image);
EXPECT_EQ("c\\z", m.snap);
EXPECT_FALSE(m.parse("a@b@c"));
EXPECT_FALSE(m.parse("a/b/c"));
EXPECT_FALSE(m.parse("a@b/c"));
}
| 4,039 | 28.489051 | 87 |
cc
|
null |
ceph-main/src/test/test_rewrite_latency.cc
|
#include <unistd.h>
#include <map>
#include <errno.h>
#include "include/utime.h"
#include "common/Clock.h"
#include "common/errno.h"
using namespace std;
int main(int argc, const char **argv)
{
const char *fn = argv[1];
multimap<utime_t, utime_t> latency;
unsigned max = 10;
int fd = ::open(fn, O_CREAT|O_RDWR, 0644);
if (fd < 1) {
int err = errno;
cerr << "failed to open " << fn << " with " << cpp_strerror(err) << std::endl;
return -1;
}
while (true) {
utime_t now = ceph_clock_now();
int r = ::pwrite(fd, fn, strlen(fn), 0);
ceph_assert(r >= 0);
utime_t lat = ceph_clock_now();
lat -= now;
utime_t oldmin;
if (!latency.empty())
oldmin = latency.begin()->first;
latency.insert(make_pair(lat, now));
utime_t newmin = latency.begin()->first;
while (latency.size() > max)
latency.erase(latency.begin());
if (oldmin == newmin) {
cout << "latency\tat" << std::endl;
for (multimap<utime_t,utime_t>::reverse_iterator p = latency.rbegin();
p != latency.rend();
++p) {
cout << p->first << "\t" << p->second << std::endl;
}
}
}
}
| 1,144 | 22.854167 | 82 |
cc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.