pax_global_header 0000666 0000000 0000000 00000000064 14167046072 0014521 g ustar 00root root 0000000 0000000 52 comment=d63de72fab679b028725bbe1c314767e689723a0
cyclonedds-0.8.2/ 0000775 0000000 0000000 00000000000 14167046072 0013657 5 ustar 00root root 0000000 0000000 cyclonedds-0.8.2/.azure/ 0000775 0000000 0000000 00000000000 14167046072 0015063 5 ustar 00root root 0000000 0000000 cyclonedds-0.8.2/.azure/coverity-scan.yml 0000664 0000000 0000000 00000007667 14167046072 0020414 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2021 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
#
# Azure Pipeline specifically for building and submitting to Coverity Scan
#
trigger: none
pr: none
schedules:
- cron: "0 12 * * 0"
branches:
include: [ master ]
always: false
strategy:
matrix:
'Ubuntu 20.04 LTS with Clang 10 (Debug, x86_64)':
image: ubuntu-20.04
cc: clang
cxx: clang++
pool:
vmImage: $(image)
steps:
## Fetch version number to ensure up-to-date cache
- bash: |
set -e
slug=$(echo "${BUILD_REPOSITORY_URI}" | sed -nE 's#.*/([^/]+/[^\]+)#\1#p')
headers=$(basename $(mktemp "$(pwd)/curl.XXXXXXXX"))
code=$(curl -X HEAD -s -S -F project="${slug}" \
-F token="${token}" \
-o /dev/null -D ${headers} -w '%{http_code}' \
"https://scan.coverity.com/download/cxx/linux64")
[ "${code}" != "200" ] && echo "cURL exited with ${code}" 1>&2 && exit 1
file=$(sed -n -E 's/.*filename="([^"]+)".*/\1/p' ${headers})
echo "###vso[task.setvariable variable=cov_archive;]${file}"
echo "###vso[task.setvariable variable=cov_analysis;]$(pwd)/cov-analysis"
echo "###vso[task.setvariable variable=PATH;]$(pwd)/cov-analysis/bin:${PATH}"
rm -f ${headers}
name: setup_coverity
env:
token: $(COVERITY_SCAN_TOKEN)
- task: Cache@2
inputs:
key: coverity | 1 | "$(cov_archive)"
path: $(cov_analysis)
cacheHitVar: coverity_cached
name: cache_coverity
## Download Coverity on cache miss
- bash: |
set -e
slug=$(echo "${BUILD_REPOSITORY_URI}" | sed -nE 's#.*/([^/]+/[^\]+)#\1#p')
headers=$(basename $(mktemp "$(pwd)/tmp.XXXXXXXX"))
code=$(curl -s -S -F project="${slug}" \
-F token="${token}" \
-O -J -D ${headers} -w '%{http_code}' \
"https://scan.coverity.com/download/cxx/linux64")
[ "${code}" != "200" ] && echo "cURL exited with ${code}" 1>&2 && exit 1
file=$(sed -n -E 's/^.*filename="([^"]+)".*$/\1/p' ${headers})
tar -xzf ${file} -C .
dir=$(find . -type d -name "cov-analysis*" | head -1)
mv "${dir}" "${COV_ANALYSIS}"
rm -f ${headers} "${file}"
name: install_coverity
condition: ne(variables['coverity_cached'], 'true')
env:
token: $(COVERITY_SCAN_TOKEN)
- bash: |
set -e -x
echo "###vso[task.setvariable variable=scan_build;]cov-build --dir $(pwd)/cov-int"
cov-configure --clang
name: configure_coverity
- template: /.azure/templates/build-test.yml
## Submit to Coverity Scan
- bash: |
set -e -x
slug=$(echo "${BUILD_REPOSITORY_URI}" | sed -nE 's#.*/([^/]+/[^\]+)#\1#p')
tar -czf analysis-results.tgz cov-int
code=$(curl -s -S -F project="${slug}" \
-F token="${token}" \
-F file=@analysis-results.tgz \
-F version=$(git rev-parse --short HEAD) \
-F description="Azure Pipelines build" \
-F email="${COVERITY_SCAN_EMAIL:=cyclonedds-inbox@eclipse.org}" \
-w '%{http_code}' \
"https://scan.coverity.com/builds")
[[ "${code}" =~ "success" ]] || (echo "cURL exited with ${code}" 1>&2 && exit 1)
rm -f analysis-results.tgz
name: submit_to_coverity_scan
env:
token: $(COVERITY_SCAN_TOKEN)
## Save Coverity build log for debugging
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: cov-int/build-log.txt
artifactName: 'coverity-build-log.txt'
cyclonedds-0.8.2/.azure/publish-documentation.yml 0000664 0000000 0000000 00000003413 14167046072 0022124 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2021 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
#
# Azure Pipeline specifically for building and publishing documentation
#
trigger:
tags:
include:
- '*'
branches:
include:
- 'master'
- 'releases/*'
pr: none
pool:
vmImage: ubuntu-20.04
steps:
- task: UsePythonVersion@0
inputs:
versionSpec: '3.9'
name: install_python
- bash: |
echo "###vso[task.setvariable variable=pip_cache;]${HOME}/.cache/pip"
sudo apt-get install -y doxygen
name: setup_linux
- task: Cache@2
inputs:
key: pip-docs | 4 | $(Agent.OS)
path: $(pip_cache)
name: cache_pip
- bash: |
set -e -x
pip install sphinx breathe exhale sphinx-rtd-theme --user --upgrade
name: install_sphinx
- bash: |
set -e -x
mkdir build
cd build
cmake .. -DBUILD_DOCS=ON
cmake --build . --target docs
name: build_documentation
- bash: |
set -e -x
if [ "${BUILD_SOURCEBRANCHNAME}" = "master" ]; then
version="latest"
else
version="$(echo ${BUILD_SOURCEBRANCHNAME} | sed -n -E 's#^.*[vV]?([0-9]+\.[0-9]+)\.[0-9]+((alpha|beta|rc)[0-9]*)?$#\1#p')"
fi
[ "${version}" != "" ] || exit 1
echo "###vso[task.setvariable variable=version;]${version}"
name: figure_version
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: build/docs/docs
artifactName: 'cyclonedds-docs-$(version)'
cyclonedds-0.8.2/.azure/templates/ 0000775 0000000 0000000 00000000000 14167046072 0017061 5 ustar 00root root 0000000 0000000 cyclonedds-0.8.2/.azure/templates/build-test.yml 0000664 0000000 0000000 00000014603 14167046072 0021664 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2021 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
#
# Template with basic build and test instructions to be included by pipelines.
#
steps:
- bash: bash versioncheck.bash
name: versioncheck
- task: UsePythonVersion@0
inputs:
versionSpec: '3.8'
name: install_python
# Set defaults from steps to share them among pipelines
- bash: |
[[ -n "${ARCH}" ]] || \
echo "###vso[task.setvariable variable=arch;]x86_64"
[[ -n "${BUILD_TYPE}" ]] || \
echo "###vso[task.setvariable variable=build_type;]Debug"
name: setup
- bash: |
echo "###vso[task.setvariable variable=pip_cache;]${HOME}/.cache/pip"
echo "###vso[task.setvariable variable=PATH;]$(python3 -m site --user-base)/bin:${PATH}"
echo "###vso[task.setvariable variable=build_tool_options;]-j 4"
sudo apt-get install -y clang clang-tools clang-tidy
condition: eq(variables['Agent.OS'], 'Linux')
name: setup_linux
- bash: |
echo "###vso[task.setvariable variable=pip_cache;]${HOME}/Library/Caches/pip"
echo "###vso[task.setvariable variable=PATH;]$(python3 -m site --user-base)/bin:${PATH}"
echo "###vso[task.setvariable variable=build_tool_options;]-j 4"
sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setglobalstate off
brew install bison
condition: eq(variables['Agent.OS'], 'Darwin')
name: setup_macos
# Use PowerShell rather than Bash to ensure Windows-style paths
- pwsh: |
$python_bin = python -m site --user-base
Write-Host "###vso[task.setvariable variable=pip_cache;]${env:LOCALAPPDATA}\\pip\\Cache"
Write-Host "###vso[task.setvariable variable=PATH;]$python_bin\\bin;${env:PATH}"
# Visual Studio is most likely used on Windows agents
if (${env:GENERATOR} -match "2019" -and -not ${env:PLATFORM}) {
# Make sure platform matches arch if not specified
if (${env:ARCH} -match "arm*") {
Write-Host "###vso[task.setvariable variable=platform;]ARM"
} elseif (${env:ARCH} -eq "x86") {
Write-Host "###vso[task.setvariable variable=platform;]Win32"
} else {
Write-Host "###vso[task.setvariable variable=platform;]x64"
}
}
if (${env:GENERATOR} -match "Visual Studio") {
Write-Host "###vso[task.setvariable variable=build_tool_options;]-nologo -verbosity:minimal -maxcpucount:4 -p:CL_MPCount=4"
} else {
Write-Host "###vso[task.setvariable variable=build_tool_options;]-j 4"
}
choco install winflexbison3
condition: eq(variables['Agent.OS'], 'Windows_NT')
name: setup_windows
- task: Cache@2
inputs:
key: pip | 2 | $(Agent.OS)
path: $(pip_cache)
name: cache_pip
- template: /.azure/templates/install-conan.yml
- bash: |
set -e -x
pip install gcovr --user --upgrade
condition: eq(variables['coverage'], 'on')
name: install_gcovr
- bash: |
set -e -x
if [[ "${ICEORYX}" = 'on' ]] ; then
sudo apt install libacl1-dev libncurses5-dev pkg-config && \
git clone https://github.com/eclipse-iceoryx/iceoryx.git && \
cd iceoryx && \
cmake -Bbuild -Hiceoryx_meta -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=${BUILD_TYPE} && \
cmake --build build && \
sudo cmake --build build --target install
fi
name: iceoryx
- bash: |
set -e -x
mkdir build
cd build
conan install -b missing -pr:b ${BUILD_PROFILE} -pr:h ${HOST_PROFILE} -s build_type=${BUILD_TYPE} ../${CONANFILE:-conanfile.txt}
cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-DCMAKE_INSTALL_PREFIX=install \
-DANALYZER=${ANALYZER:-off} \
-DSANITIZER=${SANITIZER:-none} \
-DENABLE_SSL=${SSL:-on} \
-DENABLE_SECURITY=${SECURITY:-on} \
-DENABLE_LIFESPAN=${LIFESPAN:-on} \
-DENABLE_DEADLINE_MISSED=${DEADLINE_MISSED:-on} \
-DENABLE_TYPE_DISCOVERY=${TYPE_DISCOVERY:-on} \
-DENABLE_TOPIC_DISCOVERY=${TOPIC_DISCOVERY:-on} \
-DENABLE_COVERAGE=${COVERAGE:-off} \
-DENABLE_SHM=${ICEORYX:-off} \
-DBUILD_TESTING=on \
-DBUILD_EXAMPLES=on \
-DWERROR=on \
${GENERATOR:+-G} "${GENERATOR}" -A "${PLATFORM}" -T "${TOOLSET}" ..
${SCAN_BUILD} cmake --build . --config ${BUILD_TYPE} --target install -- ${BUILD_TOOL_OPTIONS}
cmake --build . --config ${BUILD_TYPE} --target package -- ${BUILD_TOOL_OPTIONS}
name: script
- bash: |
set -e -x
cd build
ctest -j 4 --output-on-failure -T test -E '^CUnit_ddsrt_random_default_random$' -C ${BUILD_TYPE}
[[ "${BUILD_TYPE}" != 'Release' ]] || \
${SHELL} ../src/tools/ddsperf/sanity.bash
[[ "${SSL:-on}" != 'on' || "${SECURITY:-on}" != 'on' ]] || \
diff --strip-trailing-cr ../etc/cyclonedds.rnc docs/cyclonedds.rnc && \
diff --strip-trailing-cr ../etc/cyclonedds.xsd docs/cyclonedds.xsd && \
diff --strip-trailing-cr ../docs/manual/options.md docs/manual/options.md
[[ "${SANITIZER:-none}" == 'none' ]] || \
export CFLAGS="-fsanitize=${SANITIZER}" LDFLAGS="-fsanitize=${SANITIZER}"
INSTALLPREFIX="$(pwd)/install"
mkdir helloworld
cd helloworld
cmake -DCMAKE_PREFIX_PATH="${INSTALLPREFIX}" \
-DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
${GENERATOR:+-G} "${GENERATOR}" -A "${PLATFORM}" -T "${TOOLSET}" "${INSTALLPREFIX}/share/CycloneDDS/examples/helloworld"
cmake --build . --config ${BUILD_TYPE} -- ${BUILD_TOOL_OPTIONS}
name: test
- bash: |
set -e -x
cd build
cmake --build . --config ${BUILD_TYPE} --target gcov -- ${BUILD_TOOL_OPTIONS}
gcovr --exclude '.*/tests/.*' --root "${BUILD_SOURCESDIRECTORY}" --xml-pretty --output coverage.xml .
condition: eq(variables['coverage'], 'on')
name: generate_code_coverage
- task: PublishCodeCoverageResults@1
inputs:
codeCoverageTool: 'Cobertura'
summaryFileLocation: $(Build.SourcesDirectory)/build/coverage.xml
condition: eq(variables['coverage'], 'on')
name: publish_code_coverage
cyclonedds-0.8.2/.azure/templates/install-conan.yml 0000664 0000000 0000000 00000006116 14167046072 0022352 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2021 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
steps:
- bash: |
echo "###vso[task.setvariable variable=conan_cache;]${HOME}/.conan/data"
condition: ne(variables['Agent.OS'], 'Windows_NT')
name: set_conan_cache_unix
- pwsh: |
Write-Host "###vso[task.setvariable variable=conan_cache;]${env:USERPROFILE}\\.conan\\data"
# Set CONAN_BASH_PATH to avoid having to build msys2 for Conan packages.
Write-Host "###vso[task.setvariable variable=CONAN_BASH_PATH;]C:\\msys64\\usr\\bin\\bash.exe"
condition: eq(variables['Agent.OS'], 'Windows_NT')
name: set_conan_cache_windows
# Caching
- task: Cache@2
inputs:
key: conan | 4 | $(Agent.OS) | $(arch) | $(cc) | $(build_type)
path: $(conan_cache)
name: cache_conan
- bash: |
set -e
pip install conan --user --upgrade
# Derive build profile architechture from system architecture.
case "${AGENT_OSARCHITECTURE}" in
X86) build_arch=x86 ;;
X64) build_arch=x86_64 ;;
ARM) build_arch=armv8 ;;
esac
# Export Conan profile names for convenience.
# * Build platform: Platform on which the compilation tools will run.
# * Host platform: Platform on which the generated binaries will run.
#
# https://docs.conan.io/en/latest/systems_cross_building/cross_building.html
echo "###vso[task.setvariable variable=build_profile;]${build_arch}"
echo "###vso[task.setvariable variable=host_profile;]${ARCH}"
# Automatically detect the build profile. Make sure CC and CXX
# environment variables are set correctly on Microsoft Windows if a
# different compiler than Visual Studio is desired.
conan profile new ${build_arch} --detect
[[ "$(conan profile get settings.compiler ${build_arch})" != "gcc" ]] || \
conan profile update settings.compiler.libcxx=libstdc++11 ${build_arch}
[[ "$(conan profile get settings.compiler ${build_arch})" != "Visual Studio" ]] || \
[[ "${TOOLSET}" = "" ]] || \
conan profile update settings.compiler.toolset=${TOOLSET} ${build_arch}
# Generate a host profile if the architectures diverge.
if [ "${ARCH}" != "${build_arch}" ]; then
conan profile new ${ARCH} --detect
conan profile update settings.arch=${ARCH} ${ARCH}
conan profile update settings.arch_build=${ARCH} ${ARCH}
[[ "$(conan profile get settings.compiler ${ARCH})" != "gcc" ]] || \
conan profile update settings.compiler.libcxx=libstdc++11 ${ARCH}
[[ "$(conan profile get settings.compiler ${build_arch})" != "Visual Studio" ]] || \
[[ "${TOOLSET}" = "" ]] || \
conan profile update settings.compiler.toolset=${TOOLSET} ${ARCH}
fi
name: install_conan
cyclonedds-0.8.2/.codecov.yml 0000664 0000000 0000000 00000000364 14167046072 0016105 0 ustar 00root root 0000000 0000000 ignore:
- src/core/ddsc/tests/*.c
- src/core/ddsi/tests/*.c
- src/security/core/tests/*.c
- src/security/core/tests/**/*.c
- src/security/builtin_plugins/tests/*.c
- src/security/builtin_plugins/tests/**/*.c
- src/ddsrt/tests/*.c
cyclonedds-0.8.2/.gitignore 0000664 0000000 0000000 00000000130 14167046072 0015641 0 ustar 00root root 0000000 0000000 gen
gen.*
.cproject
.project
.settings/
.vs/
.vscode/
build/
docs/manual/ddsc_api_docs/
cyclonedds-0.8.2/.gitmodules 0000664 0000000 0000000 00000000000 14167046072 0016022 0 ustar 00root root 0000000 0000000 cyclonedds-0.8.2/.travis.yml 0000664 0000000 0000000 00000033353 14167046072 0015777 0 ustar 00root root 0000000 0000000 language: c
# Coverity Scan can be configured through Travis addons, but this allows for
# more control over the build instructions and does not require the addition
# of a coverity_scan branch in the repository. travisci_build_coverity_scan.sh
# does more checks before it decides to download Coverity (around 500M), but
# these instructions assume Coverity Scan is not installed if the directory
# does not exist and expects the download to fail if the token is incorrect.
# Coverity Scan quota are not checked as the Coverity enabled build must only
# run from cron.
install_coverity: &install_coverity
- if [ "${COVERITY_SCAN}" = "true" ]; then
COV_DIR="/tmp/coverity-scan-analysis";
COV_ARC="/tmp/cov-analysis-${COV_PLATFORM}.tgz";
test ! -d "${COV_DIR}" &&
mkdir -p "${COV_DIR}" &&
curl -s -S -F project="${TRAVIS_REPO_SLUG}"
-F token="${COVERITY_SCAN_TOKEN}"
-o "${COV_ARC}"
"https://scan.coverity.com/download/cxx/${COV_PLATFORM}" &&
tar -xzf "${COV_ARC}" -C "${COV_DIR}";
COV_ANALYSIS=$(find "${COV_DIR}" -type d -name "cov-analysis*");
eval "export PATH=\"${PATH}:${COV_ANALYSIS}/bin\"";
eval "export SCAN_BUILD=\"cov-build --dir cov-int\"";
cov-configure --comptype ${COV_COMPTYPE} --compiler ${CC} --template;
fi
submit_to_coverity_scan: &submit_to_coverity_scan
- if [ "${COVERITY_SCAN}" = "true" ]; then
tar -czf analysis-results.tgz cov-int &&
curl -s -S -F project="${TRAVIS_REPO_SLUG}"
-F token="${COVERITY_SCAN_TOKEN}"
-F file=@analysis-results.tgz
-F version=$(git rev-parse --short HEAD)
-F description="Travis CI build"
-F email="${COVERITY_SCAN_EMAIL:=cyclonedds-inbox@eclipse.org}"
"https://scan.coverity.com/builds";
fi
submit_to_codecov: &submit_to_codecov
- |
if [ "${CODECOV}" = "true" ]; then
query=$(curl -Gso /dev/null -w "%{url_effective}" "" \
--data-urlencode "package=cmake-codecov.io" \
--data-urlencode "token=${CODECOV_TOKEN}" \
--data-urlencode "branch=${TRAVIS_BRANCH}" \
--data-urlencode "commit=${TRAVIS_PULL_REQUEST_SHA:-$TRAVIS_COMMIT}" \
--data-urlencode "build=${TRAVIS_JOB_NUMBER}" \
--data-urlencode "tag=${TRAVIS_TAG}" \
--data-urlencode "slug=${TRAVIS_REPO_SLUG}" \
--data-urlencode "service=travis" \
--data-urlencode "flags=" \
--data-urlencode "pr=${TRAVIS_PULL_REQUEST}" \
--data-urlencode "job=${TRAVIS_JOB_ID}" 2>/dev/null | cut -c 3- | sed -e 's/%0A//');
cmake --build . --target codecov &&
curl -X POST \
--data-binary @"codecov.tar.gz" \
--retry 5 --retry-delay 2 --connect-timeout 2 \
-H 'Content-Type: text/plain' \
-H 'Content-Encoding: gzip' \
-H 'X-Content-Encoding: gzip' \
-H 'Accept: text/plain' \
"https://codecov.io/upload/v2?$query";
fi
# Coverity doesn't support gcc 10 yet
ubuntu1804_gcc7: &ubuntu1804_gcc7
os: linux
dist: bionic
compiler: gcc
before_install:
- eval "export CC=gcc CXX=g++"
- eval "export COV_COMPTYPE=gcc COV_PLATFORM=linux64"
- eval "export BUILD_TOOL_OPTIONS='-j 4'"
- eval "export GENERATOR='Unix Makefiles'"
install:
- *install_coverity
- pip install conan --upgrade --user
ubuntu1804_gcc10: &ubuntu1804_gcc10
os: linux
dist: bionic
compiler: gcc
addons:
apt:
update: true
sources:
- sourceline: 'ppa:ubuntu-toolchain-r/test'
packages: [ gcc-10 g++-10 ]
before_install:
- eval "export CC=gcc-10 CXX=g++-10"
- eval "export COV_COMPTYPE=gcc COV_PLATFORM=linux64"
- eval "export BUILD_TOOL_OPTIONS='-j 4'"
- eval "export GENERATOR='Unix Makefiles'"
install:
- pip install conan --upgrade --user
ubuntu1804_clang10: &ubuntu1804_clang10
os: linux
dist: bionic
compiler: clang
addons:
apt:
update: true
sources:
- sourceline: 'deb https://apt.llvm.org/bionic llvm-toolchain-bionic-10 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
packages: [ clang-10 clang++-10 ]
before_install:
- eval "export CC=clang-10 CXX=clang++-10"
- eval "export COV_COMPTYPE=clang COV_PLATFORM=linux64"
- eval "export BUILD_TOOL_OPTIONS='-j 4'"
- eval "export GENERATOR='Unix Makefiles'"
install:
- pip install conan --upgrade --user
macos1015_xcode11_5: &macos1015_xcode11_5
os: osx
osx_image: xcode11.5
compiler: clang
addons:
homebrew:
packages: [ python3, bison, flex ]
before_install:
- eval "export CC=clang CXX=clang++"
- eval "export COV_COMPTYPE=clang COV_PLATFORM=macOSX"
- eval "export BUILD_TOOL_OPTIONS='-j 4'"
- eval "export GENERATOR='Unix Makefiles'"
- eval "export PATH=\"${PATH}:$(python3 -m site --user-base)/bin\""
- eval "export PATH=\"/usr/local/opt/flex/bin:/usr/local/opt/bison/bin:${PATH}\""
install:
- python3 -m pip install conan --upgrade --user
freebsd12_clang8: &freebsd12_clang8
os: freebsd
compiler: clang
addons:
pkg:
packages: [ py37-pip ]
before_install:
- eval "export BUILD_TOOL_OPTIONS='-j 4'"
- eval "export GENERATOR='Unix Makefiles'"
install:
- pip install conan --upgrade --user
windows1809_vs2017: &windows1809_vs2017
os: windows
# Conan will automatically determine the best compiler for a given platform
# based on educated guesses. The first check is based on the CC and CXX
# environment variables, the second (on Windows) is to check if Microsoft
# Visual Studio is installed. On Travis CC and CXX are set to gcc on
# Microsoft Windows targets as well, this has the undesired effect that MSVC
# is not detected, unsetting CC and CXX solves that problem.
#
#
# !!! IMPORTANT !!!
#
# Microsoft Windows instances freeze at "install:" if secure environment
# variables are used. There is no option to export secrets only for
# specified platforms. The "filter_secrets: false" option is used to disable
# the filter for Microsoft Windows instances. This is not an issue if the
# secret is removed from the environment at the earliest opportunity, before
# risk of exposure, as secrets are always removed from the environment for
# pull requests and are still filtered when exported to the environment. The
# secret of course will not be available for Microsoft Windows builds, but
# for Coverity Scan, that is fine.
filter_secrets: false
before_install:
- eval "unset COVERITY_SCAN_TOKEN"
- eval "unset COVERITY_SCAN_EMAIL"
- eval "unset CC CXX"
- eval "export COV_COMPTYPE=msvc COV_PLATFORM=win64"
- eval "export BUILD_TOOL_OPTIONS='-nologo -verbosity:minimal -maxcpucount -p:CL_MPCount=2'"
- |
if [ "${ARCH}" = "x86_64" ]; then
eval "export GENERATOR='Visual Studio 15 2017 Win64'"
else
eval "export GENERATOR='Visual Studio 15 2017'"
fi
# Windows targets in Travis are still very much in beta and Python is not yet
# available and installation of Python through Chocolaty does not work well.
# The real fix is to wait until Python and pip are both available on the
# target. Until then download Conan from the official website and simply add
# the extracted folder to the path.
install:
- choco install innoextract
- choco install winflexbison3
- wget -q https://dl.bintray.com/conan/installers/conan-win-64_1_34_0.exe
- innoextract conan-win-64_1_34_0.exe
- eval "export PATH=\"$(pwd)/app/conan:${PATH}\""
jobs:
include:
- <<: *ubuntu1804_gcc7
env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES, COVERITY_SCAN=true ]
if: type = cron
- <<: *ubuntu1804_gcc7
env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES, CODECOV=true ]
if: type = cron
- <<: *ubuntu1804_gcc10
env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *ubuntu1804_gcc7
env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=NO, CONANFILE=conanfile102.txt ]
- <<: *ubuntu1804_gcc10
env: [ ARCH=x86_64, BUILD_TYPE=Release, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *ubuntu1804_gcc10
env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=NO, SECURITY=YES, LIFESPAN=NO, DEADLINE=NO, TYPE_DISCOVERY=NO, TOPIC_DISCOVERY=NO ]
- <<: *ubuntu1804_clang10
env: [ ARCH=x86_64, SANITIZER=address, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *ubuntu1804_clang10
env: [ ARCH=x86_64, SANITIZER=address, BUILD_TYPE=Debug, SSL=YES, SECURITY=NO, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *ubuntu1804_clang10
env: [ ARCH=x86_64, BUILD_TYPE=Release, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *macos1015_xcode11_5
env: [ ARCH=x86_64, BUILD_TYPE=Release, SSL=NO, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES, MACOSX_DEPLOYMENT_TARGET=10.12 ]
- <<: *macos1015_xcode11_5
env: [ ARCH=x86_64, SANITIZER=address, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *macos1015_xcode11_5
env: [ ARCH=x86_64, BUILD_TYPE=Release, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
# CUnit package in ConanCenter does not build on 32-bit Windows
#- <<: *windows1809_vs2017
# env: [ ARCH=x86, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES, CONANFILE=conanfile102.txt ]
- <<: *windows1809_vs2017
env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
- <<: *windows1809_vs2017
env: [ ARCH=x86_64, BUILD_TYPE=Release, SSL=YES, SECURITY=YES, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
# CUnit package in ConanCenter does not build on FreeBSD
#- <<: *freebsd12_clang8
# env: [ ARCH=x86_64, BUILD_TYPE=Debug, SSL=NO, SECURITY=NO, LIFESPAN=YES, DEADLINE=YES, TYPE_DISCOVERY=YES, TOPIC_DISCOVERY=YES ]
before_script:
- conan profile new default --detect
- conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan
# Notes on test settings:
# - CYCLONEDDS_URI:
# - EnableExpensiveChecks: for the few horrendously expensive (but pretty thorough)
# integrity checks, in particular on the WHC and the RHC, but there may be more
# - config to stderr: gives the configuration used when running the test in conjunction
# with "--output-on-failure" (sadly that still doesn't output the failed
# assertions ...)
# - -j 4: run 4 tests in parallel, this saves quite a bit of time because the VMs are
# all dual-core
# - --output-on-failed: print whatever output the test generated when it failed, which
# can obviously be quite helpful for debugging
# - -E ...: regex of tests to exclude:
# CUnit_ddsrt_random_default_random: performs a Chi-square test on the output of
# the random generator, but this does produce the odd failure (it should!). The
# code has been vetted, the test has been run a great many times (with the odd
# failure), and so we now simply skip the test to avoid the spurious failures.
script:
- INSTALLPREFIX="$(pwd)/install"
- mkdir build
- cd build
- conan install -b missing -s arch=${ARCH} -s build_type=${BUILD_TYPE} ../${CONANFILE:-conanfile.txt}
- cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
-DCMAKE_INSTALL_PREFIX=${INSTALLPREFIX}
-DSANITIZER=${SANITIZER}
-DENABLE_SSL=${SSL}
-DENABLE_SECURITY=${SECURITY}
-DENABLE_LIFESPAN=${LIFESPAN}
-DENABLE_DEADLINE_MISSED=${DEADLINE}
-DENABLE_TYPE_DISCOVERY=${TYPE_DISCOVERY}
-DENABLE_TOPIC_DISCOVERY=${TOPIC_DISCOVERY}
-DENABLE_COVERAGE=${CODECOV}
-DBUILD_TESTING=on
-DBUILD_EXAMPLES=on
-DWERROR=on
-G "${GENERATOR}" ..
- ${SCAN_BUILD} cmake --build . --config ${BUILD_TYPE} --target install -- ${BUILD_TOOL_OPTIONS}
- CYCLONEDDS_URI='rhc,whctrueconfigstderr' ctest -j 4 --output-on-failure -T test -E '^CUnit_ddsrt_random_default_random$' -C ${BUILD_TYPE}
- |
if [ -z "${SANITIZER}" ]; then
${SHELL} ../src/tools/ddsperf/sanity.bash;
fi
- |
if [ -n "${SANITIZER}" ]; then
CMAKE_LINKER_FLAGS="-DCMAKE_LINKER_FLAGS=-fsanitize=${SANITIZER}";
CMAKE_C_FLAGS="-DCMAKE_C_FLAGS=-fsanitize=${SANITIZER}";
fi
- |
if [ "${SSL}" = "YES" ] && [ "${SECURITY}" = "YES" ]; then
diff --strip-trailing-cr ../etc/cyclonedds.rnc docs/cyclonedds.rnc && \
diff --strip-trailing-cr ../etc/cyclonedds.xsd docs/cyclonedds.xsd && \
diff --strip-trailing-cr ../docs/manual/options.md docs/manual/options.md
fi
- cd ..
- mkdir helloworld_build
- cd helloworld_build
- cmake -DCMAKE_PREFIX_PATH=${INSTALLPREFIX}
-DCMAKE_BUILD_TYPE=${BUILD_TYPE}
${CMAKE_C_FLAGS}
${CMAKE_LINKER_FLAGS}
-G "${GENERATOR}"
${INSTALLPREFIX}/share/CycloneDDS/examples/helloworld
- cmake --build . --config ${BUILD_TYPE}
- cd "${TRAVIS_BUILD_DIR}/build"
after_success:
- *submit_to_coverity_scan
- *submit_to_codecov
cyclonedds-0.8.2/CHANGELOG.rst 0000664 0000000 0000000 00000017104 14167046072 0015703 0 ustar 00root root 0000000 0000000
Changelog for Eclipse Cyclone DDS
=================================
`Unreleased `_
---------------------------------------------------------------------------------------
`V0.7.0 (2020-08-06) `_
-----------------------------------------------------------------------------------------------
This release brings support for the DDS Security 1.1 specification:authentication, access control and encryption. It also provides significant performance improvements with large samples, by better scheduling of retransmit requests and by avoiding the occasional excessive latency caused by dropping the heartbeat rate too soon.
One can choose to build Cyclone DDS without support for DDS Security if one wants to reduce the size of the resulting library. The default plug-ins are built only if security is enabled and OpenSSL is available, as those are implemented using the cryptographic operations and I/O primitives for handling certificates and exchanging keys that OpenSSL provides. If one chooses to exclude security support from the build, setting any security related property or adding it to the configuration files will result in participant creation failing with a "precondition not met" error.
A lot of effort has gone into testing and checking that malformed or unexpected messages are handled correctly, that message authentication codes are checked and that no data never goes out unencrypted by accident. Still, it is only prudent to assume the existence of vulnerabilities.
Noteworthy bug fixes:
* DATA_AVAILABLE was not always triggered when by a dispose and sometimes triggered in the absence of an observable state change (arrival of a dispose for an already-disposed instance where the dispose had not yet been read);
* Restores functionality of the "raw ethernet" mode as well as IPv6 with link-local addresses, both accidentally broken in 0.6.0;
* Fixes a crash in processing endpoint discovery data containing unrecognised locator kinds;
* Fixes type conversion for local historical data (e.g., mixed use of ROS 2 C/C++ type supports in combination with transient-local endpoints within a single process);
* Fixes a use-after-free of "lease" objects with manual-by-topic writers;
* Mark instance as "alive" in the reader history and generate an invalid sample to notify the application even if the sample itself is dropped because the same or a later one is present already (e.g., on reconnecting to a transient-local writer);
* Fix a crash when doing an instance lookup on a built-in topic using the key value;
* No longer auto-dispose instances as soon as some registered writer disappears, instead do it only when all of them have unregistered it;
* Fix performance of read_instance and take_instance by performing a proper instance lookup.
`V0.6.0 (2020-05-21) `_
-----------------------------------------------------------------------------------------------
* Support for mixed-language programming by supporting multiple (de)serializers for a single topic in a single process. This way, a program that consists of, say, C and C++ can use a different representation of the data in C than in C++. Before, all readers/writers in the process would be forced to use the same representation (or perform an additional copy). Currently C is still the only natively supported language, but one can use an evolving-but-reasonable-stable interface to implement different mappings.
* Improved QoS support: full support for deadline, lifespan and liveliness. The first is for generating notifications when a configured instance update rate is not achieved, the second for automatically removing stale samples, the third for different modes of monitoring the liveliness of peers.
* Improved scalability in matching readers and writers. Before it used to try matching a new local or remote reader or writer with all known local & remote entities, now only with the right group with the correct topic name.
* Improved tracing: discovery data is now printed properly and user samples have more type information allowing floating-point and signed numbers to be traced in a more readable form.
* Extension of platform support
* Known to work on FreeBSD, CheriBSD
* Known to work with the musl C library
* Windows-specific changes
* Fixes multicasts to addresses also used by non-Cyclone processes (caused by accidentally linking with an old sockets library)
* Correct handling of non-English network interface names
`0.5.1 (2020-03-11) `_
-----------------------------------------------------------------------------------------------
An interim tag for the benefit of ROS2
* Enable QOS features: liveliness, lifespan, deadline
* Fix issues on Windows where multicast data was not received
`V0.5.0 (2019-11-21) `_
-------------------------------------------------------------------------------------------------
This is the fist release candidate for the long overdue second release of Eclipse Cyclone DDS.
We are updating the version number from 0.1 to 0.5 to make up for the lack of more timely releases and to reflect that progress towards a 1.0 release (a minimum profile DDS implementation + DDS security) has been more significant than a version of "0.2" would suggest.
Updates since the first release have been legion, pretty much without impact on application code or interoperatbility on the network.
Some of the highlights:
* Support for ROS2 Dashing and Eloquent (via an adaption layer).
* Support for an arbitrary number of concurrent DDS domains (fully independent instantiations of DDS) in a single process.
* Abstracting the notion of samples, types and reader history caches, allowing overriding the default implementations of these to get behaviours more suited to the applications.
This is particularly relevant to language bindings and embedding Cyclone DDS in other frameworks, such as ROS2.
* Platform support is extended beyond the usual Linux/Windows/macOS: FreeRTOS is now known to work, as is Solaris 2.6 on sun4m machines.
* Acceptance of some malformed messages from certain implementations improved interoperability on the wire.
.......................................
Limitations on backwards compatibility:
.......................................
* A change in how implicitly created "publisher" and "subscriber" entities are handled: they now never lose their "implicitness", and in consequence, are now deleted when their last child disappears rather than deleted when their one child disappears.
* The set of entities that can be attached to a waitset is now restricted to those owned by the parent of the waitset, before one was allowed to attach entities from different participants to the same waitset, which is tantamount to a bug.
* A participant entity now has a parent. The "get_parent" operation no longer returns 0 for a participant because of the addition of two additional levels to the entity hierarchy: a domain, possibly containing multiple participants; and one that represents the entire library.
* The data from a reader for a built-in topic has been extended, breaking binary compatibility.
`V0.1.0 (2019-03-06) `_
-------------------------------------------------------------------------------------------------------------------------------------
Eclipse Cyclone DDS’ first release!
cyclonedds-0.8.2/CMakeCPack.cmake 0000664 0000000 0000000 00000013241 14167046072 0016544 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2020 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
if(CMAKECPACK_INCLUDED)
return()
endif()
set(CMAKECPACK_INCLUDED true)
include(GNUInstallDirs)
set(PROJECT_NAME_FULL "Eclipse Cyclone DDS")
# Set some convenience variants of the project-name
string(REPLACE " " "-" PROJECT_NAME_DASHED "${PROJECT_NAME_FULL}")
set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
set(CPACK_PACKAGE_VERSION_TWEAK ${PROJECT_VERSION_TWEAK})
set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
set(CPACK_PACKAGE_NAME ${PROJECT_NAME})
set(CPACK_PACKAGE_VENDOR "Eclipse Cyclone DDS project")
set(CPACK_PACKAGE_CONTACT "https://github.com/eclipse-cyclonedds/cyclonedds")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Eclipse Cyclone DDS")
# WiX requires a .txt file extension for CPACK_RESOURCE_FILE_LICENSE
file(COPY "${PROJECT_SOURCE_DIR}/LICENSE" DESTINATION "${CMAKE_BINARY_DIR}")
file(RENAME "${CMAKE_BINARY_DIR}/LICENSE" "${CMAKE_BINARY_DIR}/license.txt")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_BINARY_DIR}/license.txt")
# Packages could be generated on alien systems. e.g. Debian packages could be
# created on Red Hat Enterprise Linux, but since packages also need to be
# verified on the target platform, please refrain from doing so. Another
# reason for building installer packages on the target platform is to ensure
# the binaries are linked to the libc version shipped with that platform. To
# support "generic" Linux distributions, eventually compressed tarballs will
# be shipped.
#
# NOTE: Settings for different platforms are in separate control branches.
# Although that does not make sense from a technical point-of-view, it
# does help to clearify which settings are required for a platform.
set(CPACK_COMPONENTS_ALL dev lib)
set(CPACK_COMPONENT_LIB_DISPLAY_NAME "${PROJECT_NAME_FULL} library")
set(CPACK_COMPONENT_LIB_DESCRIPTION "Library used to run programs with ${PROJECT_NAME_FULL}")
set(CPACK_COMPONENT_DEV_DISPLAY_NAME "${PROJECT_NAME_FULL} development")
set(CPACK_COMPONENT_DEV_DESCRIPTION "Development files for use with ${PROJECT_NAME_FULL}")
if(WIN32 AND NOT UNIX)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(__arch "win64")
else()
set(__arch "win32")
endif()
mark_as_advanced(__arch)
set(CPACK_GENERATOR "WIX;ZIP;${CPACK_GENERATOR}" CACHE STRING "List of package generators")
set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}-${__arch}")
set(WIX_DIR "${PROJECT_SOURCE_DIR}/WiX")
set(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME_FULL}")
set(CPACK_WIX_UI_REF "CustomUI_InstallDir")
set(CPACK_WIX_PATCH_FILE "${WIX_DIR}/env.xml")
set(CPACK_WIX_EXTRA_SOURCES "${WIX_DIR}/PathDlg.wxs"
"${WIX_DIR}/DialogOrder.wxs")
set(CPACK_WIX_CMAKE_PACKAGE_REGISTRY "${PROJECT_NAME}")
set(CPACK_WIX_PRODUCT_ICON "${WIX_DIR}/icon.ico")
set(CPACK_WIX_UI_BANNER "${WIX_DIR}/banner.png")
set(CPACK_WIX_UI_DIALOG "${WIX_DIR}/dialog.png")
# when updating the version number also generate a new GUID
set(CPACK_WIX_UPGRADE_GUID "f619c294-0696-4f04-98ed-4cfa6ebba6a5")
include(InstallRequiredSystemLibraries)
set(CMAKE_INSTALL_UCRT_LIBRARIES TRUE)
elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
set(CPACK_COMPONENTS_GROUPING "IGNORE")
if(EXISTS "/etc/redhat-release")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(__arch "x86_64")
else()
set(__arch "i686")
endif()
set(CPACK_GENERATOR "RPM;TGZ;${CPACK_GENERATOR}" CACHE STRING "List of package generators")
set(CPACK_RPM_PACKAGE_LICENSE "Eclipse Public License v2.0 http://www.eclipse.org/legal/epl-2.0")
set(CPACK_RPM_COMPONENT_INSTALL ON)
set(CPACK_RPM_PACKAGE_RELEASE 1)
set(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
set(CPACK_RPM_LIB_PACKAGE_NAME "${PROJECT_NAME_DASHED}")
set(CPACK_RPM_LIB_FILE_NAME "${CPACK_RPM_LIB_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_RPM_PACKAGE_RELEASE}%{?dist}-${__arch}.rpm")
set(CPACK_RPM_DEV_PACKAGE_NAME "${CPACK_RPM_LIB_PACKAGE_NAME}-devel")
set(CPACK_RPM_DEV_FILE_NAME "${CPACK_RPM_DEV_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_RPM_PACKAGE_RELEASE}%{?dist}-${__arch}.rpm")
set(CPACK_RPM_DEV_PACKAGE_REQUIRES "${CPACK_RPM_LIB_PACKAGE_NAME} = ${CPACK_PACKAGE_VERSION}")
elseif(EXISTS "/etc/debian_version")
set(CPACK_DEB_COMPONENT_INSTALL ON)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(__arch "amd64")
else()
set(__arch "i386")
endif()
set(CPACK_GENERATOR "DEB;TGZ;${CPACK_GENERATOR}" CACHE STRING "List of package generators")
string(TOLOWER "${PROJECT_NAME_DASHED}" CPACK_DEBIAN_LIB_PACKAGE_NAME)
set(CPACK_DEBIAN_LIB_FILE_NAME "${CPACK_DEBIAN_LIB_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}_${__arch}.deb")
set(CPACK_DEBIAN_DEV_PACKAGE_DEPENDS "${CPACK_DEBIAN_LIB_PACKAGE_NAME} (= ${CPACK_PACKAGE_VERSION}), libc6 (>= 2.23)")
set(CPACK_DEBIAN_DEV_PACKAGE_NAME "${CPACK_DEBIAN_LIB_PACKAGE_NAME}-dev")
set(CPACK_DEBIAN_DEV_FILE_NAME "${CPACK_DEBIAN_DEV_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}_${__arch}.deb")
else()
# Generic tgz package
set(CPACK_GENERATOR "TGZ;${CPACK_GENERATOR}" CACHE STRING "List of package generators")
endif()
else()
# Fallback to zip package
set(CPACK_GENERATOR "ZIP;${CPACK_GENERATOR}" CACHE STRING "List of package generators")
endif()
# This must always be last!
include(CPack)
cyclonedds-0.8.2/CMakeLists.txt 0000664 0000000 0000000 00000027552 14167046072 0016432 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2006 to 2019 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
cmake_minimum_required(VERSION 3.7)
project(CycloneDDS VERSION 0.8.2 LANGUAGES C)
if(CMAKE_VERSION VERSION_LESS 3.12)
# GENERATE_EXPORT_HEADER requires a C++ compiler up to version 3.12
enable_language(CXX)
endif()
# Set a default build type if none was specified
set(default_build_type "RelWithDebInfo")
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
STRING "Choose the type of build." FORCE)
# Set the possible values of build type for cmake-gui
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()
if(CMAKE_CROSSCOMPILING)
set(not_crosscompiling OFF)
else()
set(not_crosscompiling ON)
endif()
# By default don't treat warnings as errors, else anyone building it with a different compiler that
# just happens to generate a warning, as well as anyone adding or modifying something and making a
# small mistake would run into errors. CI builds can be configured differently.
option(WERROR "Treat compiler warnings as errors" OFF)
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules")
option(BUILD_IDLC "Build IDL preprocessor" ${not_crosscompiling})
option(BUILD_DDSCONF "Build DDSCONF buildtool" ${not_crosscompiling})
set(CMAKE_C_STANDARD 99)
if(CMAKE_SYSTEM_NAME STREQUAL "VxWorks")
add_definitions(-std=c99)
endif()
if(${CMAKE_C_COMPILER_ID} STREQUAL "SunPro")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m64 -xc99 -D__restrict=restrict -D__deprecated__=")
set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS} -m64")
elseif(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m64")
set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS} -m64")
endif()
# Homebrew
if(APPLE)
# Hint Homebrew prefixes to find_* commands. Use of CMAKE_PREFIX_PATH is
# required because full signature mode for find_package implies Config mode.
find_program(brew NAMES brew)
if (brew)
foreach(formula bison)
execute_process(
COMMAND ${brew} --prefix ${formula}
OUTPUT_VARIABLE prefix
ERROR_QUIET)
string(STRIP "${prefix}" prefix)
if(EXISTS "${prefix}")
# Append to ensure user specified paths come first.
set(CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH};${prefix}")
endif()
endforeach()
endif()
endif()
# Conan
if(EXISTS "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
if(APPLE)
# By default Conan strips all RPATHs (see conanbuildinfo.cmake), which
# causes tests to fail as the executables cannot find the library target.
# By setting KEEP_RPATHS, Conan does not set CMAKE_SKIP_RPATH and the
# resulting binaries still have the RPATH information. This is fine because
# CMake will strip the build RPATH information in the install step.
#
# NOTE:
# Conan's default approach is to use the "imports" feature, which copies
# all the dependencies into the bin directory. Of course, this doesn't work
# quite that well for libraries generated in this Project (see Conan
# documentation).
#
# See the links below for more information.
# https://github.com/conan-io/conan/issues/337
# https://docs.conan.io/en/latest/howtos/manage_shared_libraries/rpaths.html
# https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/RPATH-handling
conan_basic_setup(KEEP_RPATHS)
else()
conan_basic_setup()
endif()
conan_define_targets()
endif()
# Set reasonably strict warning options for clang, gcc, msvc
# Enable coloured ouput if Ninja is used for building
if("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
"${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
#message(STATUS clang)
set(wflags "-Wall"
"-Wextra"
"-Wconversion"
"-Wunused"
"-Wmissing-prototypes"
"-Winfinite-recursion"
"-Wassign-enum"
"-Wcomma"
"-Wmissing-prototypes"
"-Wdocumentation"
"-Wstrict-prototypes"
"-Wconditional-uninitialized"
"-Wshadow")
add_compile_options(${wflags})
if(${WERROR})
add_compile_options(-Werror)
endif()
if("${CMAKE_GENERATOR}" STREQUAL "Ninja")
add_compile_options(-Xclang -fcolor-diagnostics)
endif()
elseif("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
#message(STATUS gcc)
add_compile_options(-Wall -Wextra -Wconversion -Wmissing-prototypes)
if(${WERROR})
add_compile_options(-Werror)
endif()
if("${CMAKE_GENERATOR}" STREQUAL "Ninja")
add_compile_options(-fdiagnostics-color=always)
endif()
elseif("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
#message(STATUS msvc)
add_compile_options(/W3)
if(${WERROR})
add_compile_options(/WX)
endif()
endif()
# I don't know how to enable warnings properly so that they are enabled in Xcode projects as well
if(${CMAKE_GENERATOR} STREQUAL "Xcode")
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_EMPTY_BODY YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_SHADOW YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_BOOL_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_CONSTANT_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_64_TO_32_BIT_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_FLOAT_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_INT_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_NON_LITERAL_NULL_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_IMPLICIT_SIGN_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_INFINITE_RECURSION YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_RETURN_TYPE YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_MISSING_PARENTHESES YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_NEWLINE YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_ASSIGN_ENUM YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_SEMICOLON_BEFORE_METHOD_BODY YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_SIGN_COMPARE YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_STRICT_PROTOTYPES YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_COMMA YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNINITIALIZED_AUTOS YES_AGGRESSIVE)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_FUNCTION YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_LABEL YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_PARAMETER YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VALUE YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VARIABLE YES)
set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_DOCUMENTATION_COMMENTS YES)
set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_PROTOTYPES YES)
endif()
if(CMAKE_VERSION VERSION_LESS 3.13)
macro(add_link_options)
link_libraries(${ARGV})
endmacro()
endif()
# Make it easy to enable MSVC, Clang's/gcc's analyzers
set(ANALYZER "" CACHE STRING "Analyzer to enable on the build.")
if(ANALYZER)
# GCC and Visual Studio offer builtin analyzers. Clang supports static
# analysis through separate tools, e.g. Clang-Tidy, which can be used in
# conjunction with other compilers too. Specifying -DANALYZER=on enables
# the builtin analyzer for the compiler, enabling clang-tidy in case of
# Clang. Specifying -DANALYZER=clang-tidy always enables clang-tidy.
string(REPLACE " " "" ANALYZER "${ANALYZER}")
string(TOLOWER "${ANALYZER}" ANALYZER)
if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND ANALYZER STREQUAL "on")
set(ANALYZER "clang-tidy")
endif()
if(ANALYZER STREQUAL "clang-tidy")
# Clang-Tidy is an extensible tool that offers more than static analysis.
# https://clang.llvm.org/extra/clang-tidy/checks/list.html
message(STATUS "Enabling analyzer: clang-tidy")
set(CMAKE_C_CLANG_TIDY "clang-tidy;-checks=-*,clang-analyzer-*,-clang-analyzer-security.insecureAPI.strcpy")
if(WERROR)
set(CMAKE_C_CLANG_TIDY "${CMAKE_C_CLANG_TIDY};--warnings-as-errors=*")
endif()
elseif(ANALYZER STREQUAL "on")
if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL "10")
message(STATUS "Enabling analyzer: GCC")
# -Wanalyzer-malloc-leak generates lots of false positives
add_compile_options(-fanalyzer -Wno-analyzer-malloc-leak)
endif()
endif()
endif()
endif()
set(SANITIZER "" CACHE STRING "Sanitizers to enable on the build.")
if(SANITIZER)
string(REGEX REPLACE " " "" SANITIZER "${SANITIZER}")
string(REGEX REPLACE "[,;]+" ";" SANITIZER "${SANITIZER}")
foreach(san ${SANITIZER})
if(san STREQUAL "address")
add_compile_options("-fno-omit-frame-pointer")
add_link_options("-fno-omit-frame-pointer")
endif()
if(san AND NOT san STREQUAL "none")
message(STATUS "Enabling sanitizer: ${san}")
add_compile_options("-fsanitize=${san}")
add_link_options("-fsanitize=${san}")
endif()
endforeach()
endif()
find_package(codecov)
set(MEMORYCHECK_COMMAND_OPTIONS "--track-origins=yes --leak-check=full --trace-children=yes --child-silent-after-fork=yes --xml=yes --xml-file=TestResultValgrind_%p.xml --tool=memcheck --show-reachable=yes --leak-resolution=high")
# By default building the testing tree is enabled by including CTest, but
# since not everybody has CUnit, and because it is not strictly required to
# build the product itself, switch to off by default.
option(BUILD_TESTING "Build the testing tree." OFF)
# Disable building examples by default because it is not strictly required.
option(BUILD_EXAMPLES "Build examples." OFF)
option(BUILD_DOCS "Build documentation." OFF)
option(BUILD_SCHEMA "Build generated schema for configuration options." ${not_crosscompiling})
# Build all executables and libraries into the top-level /bin and /lib folders.
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
include(CMakePackageConfigHelpers)
include(GNUInstallDirs)
include(CTest)
if(APPLE)
set(CMAKE_INSTALL_RPATH "@loader_path/../${CMAKE_INSTALL_LIBDIR}")
else()
set(CMAKE_INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
endif()
if(MINGW)
# Require at least Windows 7
add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WIN7)
add_definitions(-DNTDDI_VERSION=NTDDI_WIN7)
add_definitions(-D__USE_MINGW_ANSI_STDIO=1) # prefer C99 conformance
# Do not prefix libraries with "lib"
set(CMAKE_SHARED_LIBRARY_PREFIX "")
set(CMAKE_STATIC_LIBRARY_PREFIX "")
endif()
set(CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
# Generate Config.cmake
configure_package_config_file(
"PackageConfig.cmake.in"
"${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}")
# Generate Version.cmake
write_basic_package_version_file(
"${PROJECT_NAME}ConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY SameMajorVersion)
install(
FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
COMPONENT dev)
# Generate Targets.cmake
install(
EXPORT ${PROJECT_NAME}
FILE "${PROJECT_NAME}Targets.cmake"
NAMESPACE "${PROJECT_NAME}::"
DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
COMPONENT dev)
add_subdirectory(src)
if(BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
add_subdirectory(docs)
include(CMakeCPack.cmake)
cyclonedds-0.8.2/CONTRIBUTING.md 0000664 0000000 0000000 00000002710 14167046072 0016110 0 ustar 00root root 0000000 0000000 # Contributing to Eclipse Cyclone DDS
Thanks for your interest in this project.
## Project description
Eclipse Cyclone DDS is an implementation of the OMG Data Distribution Service
(DDS) specification (see http://www.omg.org/spec/DDS/ ) and the related
specifications for interoperability (see http://www.omg.org/spec/DDSI-RTPS/ )
* https://projects.eclipse.org/projects/iot.cyclonedds
## Developer resources
Information regarding source code management, builds, coding standards, and
more.
* https://projects.eclipse.org/projects/iot.cyclonedds/developer
The project maintains the following source code repositories
* https://github.com/eclipse/cyclonedds
## Eclipse Contributor Agreement
Before your contribution can be accepted by the project team contributors must
electronically sign the Eclipse Contributor Agreement (ECA).
* http://www.eclipse.org/legal/ECA.php
Commits that are provided by non-committers must have a Signed-off-by field in
the footer indicating that the author is aware of the terms by which the
contribution has been provided to the project. The non-committer must
additionally have an Eclipse Foundation account and must have a signed Eclipse
Contributor Agreement (ECA) on file.
For more information, please see the Eclipse Committer Handbook:
https://www.eclipse.org/projects/handbook/#resources-commit
## Contact
Contact the project developers via the project's "dev" list.
* https://accounts.eclipse.org/mailing-list/cyclonedds-dev
cyclonedds-0.8.2/CYCLONEDDS_QUALITY_DECLARATION.md 0000664 0000000 0000000 00000036472 14167046072 0020661 0 ustar 00root root 0000000 0000000 This document is a declaration of software quality for the [Eclipse Cyclone DDS](https://github.com/eclipse-cyclonedds/cyclonedds) (hereafter simply "Cyclone DDS") project, based on the guidelines in [REP-2004](https://www.ros.org/reps/rep-2004.html). This quality declaration is therefore specific to use in [ROS 2](https://index.ros.org/doc/ros2/)-based systems.
# Cyclone DDS Quality Declaration
Cyclone DDS meets all the requirements of **Quality Level 2** category.
The requirements for the various quality level categories are defined by [REP-2004](https://www.ros.org/reps/rep-2004.html).
The rationale, notes and caveats for this claim are provided by the remainder of this document.
## Version Policy [1]
### Version Scheme [1.i]
Cyclone DDS version numbers are organised as MAJOR.MINOR.PATCH where all three components are non-negative decimal numbers.
Version number policy follows the following rules:
* MAJOR version is incremented when an incompatible API change is made;
* MINOR version when functionality is added in a backwards compatible manner. MINOR is source compatible, the project strives to also maintain binary compatibility;
* PATCH version when backwards compatible bug fixes are made. PATCH is binary compatible.
On incrementing a number, all numbers to the right of it are reset to 0.
Major version 0 is considered stable.
Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format and start at the first character following the PATCH that is not a decimal digit.
See also the [Releases section](https://www.eclipse.org/projects/handbook/#release) of the Eclipse project handbook which discusses _Major_, _Minor_, and _Service_ release criteria (where _Service_ corresponds to PATCH in the above description.
### Version Stability [1.ii]
Cyclone DDS is at a stable version.
The current version is the highest versioned Git tag that consists of three decimal numbers separated by periods.
For each minor release, there exists a releases/MAJOR.MINOR.x branch that is used for PATCH releases.
The change history can be found in the [CHANGELOG](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/CHANGELOG.rst).
### Public API Declaration [1.iii]
Symbols starting with `dds_` or `DDS_` and that are accessible after including only the top-level `dds.h` file, unless explicitly stated otherwise in a documentation comment, constitute the Public API.
Definitions available in installed include files that are outside this definitions are either internal or part of an Evolving API that is expected to eventually become part of the Public API. Internal definitions are deliberately included in the install: the project chooses not to artifically limit users of Cyclone DDS to the Public or Evolving APIs.
In the source repository, these header files reside with the modules that make up Cyclone DDS.
### API Stability Policy [1.iv]
For the Public API:
* Cyclone DDS provides Public API stability for PATCH and MINOR releases.
* Cyclone DDS strives to provide Public API stability for MAJOR releases.
* Cyclone DDS does not guarantee Public API stability for MAJOR releases.
For the Evolving API:
* Cyclone DDS provides Evolving API stability for PATCH releases.
* Cyclone DDS strives to provide Evolving API stability for MINOR releases.
* Cyclone DDS does not guarantee Evolving API stability for MINOR and MAJOR releases.
The RMW interface is what ROS 2 deals with, and for a variety of reasons it may be decided to rely on unstable interfaces (or even implementation details), to better support ROS 2's design decisions that do not fit so well with DDS.
Given ROS 2's importance to Cyclone DDS the Public API is expected to eventually cover all of ROS 2's needs, but without a defined time-line for that to happen.
The Cyclone DDS projects takes these uses into account, but it may at times even require source changes to the RMW layer.
As the Cyclone DDS project is actively involved in maintaining the RMW layer, such cases are handled by scheduling updates and performing additional compatibility checks against the ROS 2 test suite to ensure they do not cause any disruption to ROS 2.
Those changes are all hidden in the interface between the RMW layer and Cyclone DDS itself and are of no concern to ROS 2 applications.
It just means that, in the general case, one should always use a matched pair of `rmw_cyclonedds_cpp` and `cyclonedds`.
### ABI Stability Policy [1.v]
Cyclone DDS provides ABI stability for PATCH releases and strives to provide ABI stability for MINOR releases, for both Public and Evolving APIs.
Cyclone DDS does not guarantee ABI stability for MINOR or MAJOR releases.
### ABI and ABI Stability Within a Released ROS Distribution [1.vi]
ROS 2 users do not interact directly with Cyclone DDS and the mapping of the RMW interface to the Cyclone DDS APIs provided by the `rmw_cyclonedds` package hides any API or ABI changes from ROS 2 users.
Based on the ABI Stability Policy, Cyclone DDS PATCH releases can be accepted as updates within a Released ROS Distribution. MINOR releases can likely be accepted as updates after assessing the binary compatibility.
Cyclone DDS MINOR and MAJOR releases can, at least in principle, be accepted as updates within a Released ROS Distribution if the update is accompanied by an update of the `rmw_cyclonedds` package.
## Change Control [2]
Cyclone DDS follows the recommended guidelines of the [Eclipse Development Process](https://www.eclipse.org/projects/dev_process/).
The Eclipse Foundation manages write access to project repositories, allowing only designated [Committers](https://www.eclipse.org/projects/dev_process/#4_1_Committers), who have been voted for in elections overseen by the Eclipse Foundation, to commit changes.
API and ABI stability is part of the review process. The Cyclone DDS project runs CI and tests.
The Cyclone DDS project runs ROS CI for changes that are likely to affect ROS.
### Change Requests [2.i]
All changes occur through a pull request.
### Contributor Origin [2.ii]
This package uses DCO as its confirmation of contributor origin policy.
More information can be found in [Eclipse Foundation's DCO policy](https://www.eclipse.org/legal/DCO.php).
Eclipse projects furthermore require that an [Eclipse Contributor Agreement](https://www.eclipse.org/legal/ECA.php) is on file with the Eclipse Foundation.
### Peer Review Policy [2.iii]
All pull requests must pass peer-review except when no-one is able to provide a review for a PR introduced by a Committer. The exception exists solely as an escape hatch if no review can be obtained within a reasonable time frame while there is an urgent need for the change introduced by the PR.
Check [Eclipse Developer Process](https://www.eclipse.org/projects/dev_process/) for additional information.
### Continuous Integration [2.iv]
Pull requests are required to pass all tests in the CI system prior to merging, unless Committers consider there is sufficient evidence that a failure is the result of a mishap unrelated to the change.
Cyclone DDS CI results are [public](https://dev.azure.com/eclipse-cyclonedds/cyclonedds/_build) and cover x64 and x86 platforms running Linux, macOS and Windows:
- Ubuntu 20.04 with gcc 10
- Ubuntu 18.04 with gcc 7
- Ubuntu 20.04 with clang 10
- macOS 10.15 with clang 12
- macOS 10.15 with clang 12 while targeting macOS 10.12
- Windows Server 2019 with Visual Studio 2019
- Windows Server 2019 with gcc 10 (mingw)
These are run with a mixture of debug, debug-with-address sanitizer and release builds.
ROS 2 CI also runs the Cyclone DDS tests, which provides further coverage, including the exact platforms used for ROS 2 releases.
### Documentation Policy [2.v]
All pull requests must resolve related documentation changes before merging.
## Documentation [3]
### Feature Documentation [3.i]
The project documentation includes a getting started that introduces the high-level concepts, but it generally prefers to instead refer to the [OMG DDS specification](https://www.omg.org/spec/DDS/1.4/PDF) for an accessible and full description of the concepts and high-level features.
Some components can be enabled/disabled at compile-time through compilation options from the CMake files (e.g., DDS Security support). These are done with CMake options.
Some other features are included/excluded at build time based on the features provided by the target platform (e.g., source-specific multicasting, DNS support to allow hostnames to be used in the configuration). All features are available on the tier 1 platforms, the ability to exclude them is needed for embedded platforms such as FreeRTOS.
### Public API Documentation [3.ii]
Reference information for the Public API is provided in the form of Doxygen comments. Generated documentation is provided [online](https://cyclonedds.io).
Configuration settings are documented in the source, with auto-generated [XSD files](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/etc/cyclonedds.xsd) and [markdown files](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/docs/manual/options.md) committed in the repository and linked from the front page.
[Background information](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/docs/manual/config.rst) on configuration settings is also provided.
### License [3.iii]
The license for Cyclone DDS is the Eclipse Public License 2.0 and the Eclipse Distribution License 1.0, and all of the code includes a header stating so.
The project includes a [`NOTICE`](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/NOTICE.md#declared-project-licenses) with links to more information about these licenses.
The Cyclone DDS repository also includes a [`LICENSE`](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/LICENSE) file with the full terms.
There is some third-party content included with Cyclone DDS which is licensed as Zlib, New BSD, and Public Domain.
Details can also be found in the included [`NOTICE`](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/NOTICE.md#third-party-content) document.
### Copyright Statement [3.iv]
The Cyclone DDS documentation includes a [policy](https://github.com/eclipse-cyclonedds/cyclonedds/blob/master/NOTICE.md#copyright) regarding content copyright, each of the source files containing code include a copyright statement with the license information in the file's header.
### Lists and Peer Review [3.v.c]
This section is not applicable to a non-ROS project.
## Testing [4]
Cyclone DDS source tree includes subdirectories for test code.
In all, the test code comprises approximately 25% of the codebase.
### Feature Testing [4.i]
Each feature in Cyclone DDS has corresponding tests which simulate typical usage, and they are located in separate directories next to the sources.
New features are required to have tests before being added.
A substantial amount of the tests found throughout the source tree verify functionality of various features of Cyclone DDS.
### Public API Testing [4.ii]
Each part of the public API has tests, and new additions or changes to the public API require tests before being added.
The tests aim to cover both typical usage and corner cases.
There are some tests throughout the Cyclone DDS source tree which specifically target the public API.
There is no automated tracking of correlation between tests and API functionality. On the basis of a manual assessment conducted by the project, the overall number of tests and the number of reported issues, it is fair to conclude that the Public API is well-covered.
In continuous integration, address sanitizer is enabled for some of the test matrix. Address sanitizer errors result in CI failure.
### Coverage [4.iii]
Cyclone DDS publishes [test coverage](https://codecov.io/github/eclipse-cyclonedds/cyclonedds?branch=master) using [Codecov](https://codecov.io).
New changes are required to include tests coverage. Line coverage is approximately 75% (as of 2020-09-04).
### Performance [4.iv]
While there are no automated, public tests or results, there is evidence in PRs that performance does get taken into account (see, e.g., https://github.com/eclipse-cyclonedds/cyclonedds#558).
`ddsperf` is used to check for performance regressions regularly and before releases.
Performance-sensitive PRs are tested for regressions using ddsperf before changes are accepted.
[ddsperf](https://github.com/eclipse-cyclonedds/cyclonedds/tree/master/src/tools/ddsperf) is the tool to use for assessing Cyclone DDS performance.
ros2 [nightly CI performance tests](http://build.ros2.org/job/Fci__nightly-performance_ubuntu_focal_amd64/) exist but is not reliable infrastructure.
We suggest and would like to assist Open Robotics to move all performance testing to dedicated hardware.
### Linters and Static Analysis [4.v]
`rmw_cyclonedds` uses and passes all the ROS2 standard linters and static analysis tools for a C++ package as described in the [ROS 2 Developer Guide](https://index.ros.org/doc/ros2/Contributing/Developer-Guide/#linters-and-static-analysis).
Passing implies there are no linter/static errors when testing against CI of supported platforms.
Cyclone DDS has automated [Synopsys Coverity static code analysis](https://www.synopsys.com/software-integrity/security-testing/static-analysis-sast.html) with public results that can be seen [here](https://scan.coverity.com/projects/eclipse-cyclonedds-cyclonedds).
Cyclone DDS has no outstanding defects as of 20-09-2021 on 240k lines analyzed. For comparison the average defect density of open source software projects of similar size is 0.5 per 1,000 lines of code.
Coding style is considered and enforced in the review of all Cyclone DDS pull requests.
Contributors are regularly asked to rewrite or reformat their code contributions before pull requests are accepted.
This is a matter of public record in the Cyclone DDS pull request history.
## Dependencies [5]
### Direct Runtime ROS Dependencies [5.i]
As an external dependency, there are no ROS dependencies in Cyclone DDS.
### Optional Direct Runtime ROS Dependencies [5.ii]
As an external dependency, there are no ROS dependencies in Cyclone DDS.
### Direct Runtime non-ROS Dependency [5.iii]
The only runtime dependency of Cyclone DDS is [OpenSSL](https://openssl.org), a widely-used secure communications suite.
If Cyclone DDS is built without security enabled, the product has no runtime dependencies.
## Platform Support [6]
Cyclone DDS supports all of the tier 1 platforms as described in REP-2000.
Cyclone DDS CI test coverage does not exactly match the tier 1 platforms of ROS 2.
The ROS 2 CI includes the Cyclone DDS CI tests, and so there is automated validation that all tier 1 platforms are fully supported.
Regarding minimum versions they are basically not known exactly because Cyclone DDS builds and runs on everything that was tested including ancient versions of Linux and macOS.
For evidence, the fact that Cyclone DDS builds and runs on [Solaris 2.6 on SPARCv8](https://github.com/eclipse-cyclonedds/cyclonedds/tree/master/ports/solaris2.6) (given pre-generated header files and IDL output) is a fair indication of its broad support of platforms and old versions.
The README specifies mininum versions that are new enough.
## Security [7]
### Vulnerability Disclosure Policy [7.i]
This package conforms to the Vulnerability Disclosure Policy in REP-2006.
The Eclipse Project Handbook states the project's [vulnerability disclosure policy](https://www.eclipse.org/projects/handbook/#vulnerability-disclosure) in detail.
cyclonedds-0.8.2/LICENSE 0000664 0000000 0000000 00000037313 14167046072 0014673 0 ustar 00root root 0000000 0000000 This program and the accompanying materials are made available under the
terms of the Eclipse Public License v. 2.0 which is available at
http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
v. 1.0 which is available at
http://www.eclipse.org/org/documents/edl-v10.php.
Eclipse Public License - v 2.0
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial content
Distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program originate from
and are Distributed by that particular Contributor. A Contribution
"originates" from a Contributor if it was added to the Program by
such Contributor itself or anyone acting on such Contributor's behalf.
Contributions do not include changes or additions to the Program that
are not Modified Works.
"Contributor" means any person or entity that Distributes the Program.
"Licensed Patents" mean patent claims licensable by a Contributor which
are necessarily infringed by the use or sale of its Contribution alone
or when combined with the Program.
"Program" means the Contributions Distributed in accordance with this
Agreement.
"Recipient" means anyone who receives the Program under this Agreement
or any Secondary License (as applicable), including Contributors.
"Derivative Works" shall mean any work, whether in Source Code or other
form, that is based on (or derived from) the Program and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship.
"Modified Works" shall mean any work in Source Code or other form that
results from an addition to, deletion from, or modification of the
contents of the Program, including, for purposes of clarity any new file
in Source Code form that contains any contents of the Program. Modified
Works shall not include works that contain only declarations,
interfaces, types, classes, structures, or files of the Program solely
in each case in order to link to, bind by name, or subclass the Program
or Modified Works thereof.
"Distribute" means the acts of a) distributing or b) making available
in any manner that enables the transfer of a copy.
"Source Code" means the form of a Program preferred for making
modifications, including but not limited to software source code,
documentation source, and configuration files.
"Secondary License" means either the GNU General Public License,
Version 2.0, or any later versions of that license, including any
exceptions or additional permissions as identified by the initial
Contributor.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each Contributor hereby
grants Recipient a non-exclusive, worldwide, royalty-free copyright
license to reproduce, prepare Derivative Works of, publicly display,
publicly perform, Distribute and sublicense the Contribution of such
Contributor, if any, and such Derivative Works.
b) Subject to the terms of this Agreement, each Contributor hereby
grants Recipient a non-exclusive, worldwide, royalty-free patent
license under Licensed Patents to make, use, sell, offer to sell,
import and otherwise transfer the Contribution of such Contributor,
if any, in Source Code or other form. This patent license shall
apply to the combination of the Contribution and the Program if, at
the time the Contribution is added by the Contributor, such addition
of the Contribution causes such combination to be covered by the
Licensed Patents. The patent license shall not apply to any other
combinations which include the Contribution. No hardware per se is
licensed hereunder.
c) Recipient understands that although each Contributor grants the
licenses to its Contributions set forth herein, no assurances are
provided by any Contributor that the Program does not infringe the
patent or other intellectual property rights of any other entity.
Each Contributor disclaims any liability to Recipient for claims
brought by any other entity based on infringement of intellectual
property rights or otherwise. As a condition to exercising the
rights and licenses granted hereunder, each Recipient hereby
assumes sole responsibility to secure any other intellectual
property rights needed, if any. For example, if a third party
patent license is required to allow Recipient to Distribute the
Program, it is Recipient's responsibility to acquire that license
before distributing the Program.
d) Each Contributor represents that to its knowledge it has
sufficient copyright rights in its Contribution, if any, to grant
the copyright license set forth in this Agreement.
e) Notwithstanding the terms of any Secondary License, no
Contributor makes additional grants to any Recipient (other than
those set forth in this Agreement) as a result of such Recipient's
receipt of the Program under the terms of a Secondary License
(if permitted under the terms of Section 3).
3. REQUIREMENTS
3.1 If a Contributor Distributes the Program in any form, then:
a) the Program must also be made available as Source Code, in
accordance with section 3.2, and the Contributor must accompany
the Program with a statement that the Source Code for the Program
is available under this Agreement, and informs Recipients how to
obtain it in a reasonable manner on or through a medium customarily
used for software exchange; and
b) the Contributor may Distribute the Program under a license
different than this Agreement, provided that such license:
i) effectively disclaims on behalf of all other Contributors all
warranties and conditions, express and implied, including
warranties or conditions of title and non-infringement, and
implied warranties or conditions of merchantability and fitness
for a particular purpose;
ii) effectively excludes on behalf of all other Contributors all
liability for damages, including direct, indirect, special,
incidental and consequential damages, such as lost profits;
iii) does not attempt to limit or alter the recipients' rights
in the Source Code under section 3.2; and
iv) requires any subsequent distribution of the Program by any
party to be under a license that satisfies the requirements
of this section 3.
3.2 When the Program is Distributed as Source Code:
a) it must be made available under this Agreement, or if the
Program (i) is combined with other material in a separate file or
files made available under a Secondary License, and (ii) the initial
Contributor attached to the Source Code the notice described in
Exhibit A of this Agreement, then the Program may be made available
under the terms of such Secondary Licenses, and
b) a copy of this Agreement must be included with each copy of
the Program.
3.3 Contributors may not remove or alter any copyright, patent,
trademark, attribution notices, disclaimers of warranty, or limitations
of liability ("notices") contained within the Program from any copy of
the Program which they Distribute, provided that Contributors may add
their own appropriate notices.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain responsibilities
with respect to end users, business partners and the like. While this
license is intended to facilitate the commercial use of the Program,
the Contributor who includes the Program in a commercial product
offering should do so in a manner which does not create potential
liability for other Contributors. Therefore, if a Contributor includes
the Program in a commercial product offering, such Contributor
("Commercial Contributor") hereby agrees to defend and indemnify every
other Contributor ("Indemnified Contributor") against any losses,
damages and costs (collectively "Losses") arising from claims, lawsuits
and other legal actions brought by a third party against the Indemnified
Contributor to the extent caused by the acts or omissions of such
Commercial Contributor in connection with its distribution of the Program
in a commercial product offering. The obligations in this section do not
apply to any claims or Losses relating to any actual or alleged
intellectual property infringement. In order to qualify, an Indemnified
Contributor must: a) promptly notify the Commercial Contributor in
writing of such claim, and b) allow the Commercial Contributor to control,
and cooperate with the Commercial Contributor in, the defense and any
related settlement negotiations. The Indemnified Contributor may
participate in any such claim at its own expense.
For example, a Contributor might include the Program in a commercial
product offering, Product X. That Contributor is then a Commercial
Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance
claims and warranties are such Commercial Contributor's responsibility
alone. Under this section, the Commercial Contributor would have to
defend claims against the other Contributors related to those performance
claims and warranties, and if a court requires any other Contributor to
pay any damages as a result, the Commercial Contributor must pay
those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
PURPOSE. Each Recipient is solely responsible for determining the
appropriateness of using and distributing the Program and assumes all
risks associated with its exercise of rights under this Agreement,
including but not limited to the risks and costs of program errors,
compliance with applicable laws, damage to or loss of data, programs
or equipment, and unavailability or interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under
applicable law, it shall not affect the validity or enforceability of
the remainder of the terms of this Agreement, and without further
action by the parties hereto, such provision shall be reformed to the
minimum extent necessary to make such provision valid and enforceable.
If Recipient institutes patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the
Program itself (excluding combinations of the Program with other software
or hardware) infringes such Recipient's patent(s), then such Recipient's
rights granted under Section 2(b) shall terminate as of the date such
litigation is filed.
All Recipient's rights under this Agreement shall terminate if it
fails to comply with any of the material terms or conditions of this
Agreement and does not cure such failure in a reasonable period of
time after becoming aware of such noncompliance. If all Recipient's
rights under this Agreement terminate, Recipient agrees to cease use
and distribution of the Program as soon as reasonably practicable.
However, Recipient's obligations under this Agreement and any licenses
granted by Recipient relating to the Program shall continue and survive.
Everyone is permitted to copy and distribute copies of this Agreement,
but in order to avoid inconsistency the Agreement is copyrighted and
may only be modified in the following manner. The Agreement Steward
reserves the right to publish new versions (including revisions) of
this Agreement from time to time. No one other than the Agreement
Steward has the right to modify this Agreement. The Eclipse Foundation
is the initial Agreement Steward. The Eclipse Foundation may assign the
responsibility to serve as the Agreement Steward to a suitable separate
entity. Each new version of the Agreement will be given a distinguishing
version number. The Program (including Contributions) may always be
Distributed subject to the version of the Agreement under which it was
received. In addition, after a new version of the Agreement is published,
Contributor may elect to Distribute the Program (including its
Contributions) under the new version.
Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
receives no rights or licenses to the intellectual property of any
Contributor under this Agreement, whether expressly, by implication,
estoppel or otherwise. All rights in the Program not expressly granted
under this Agreement are reserved. Nothing in this Agreement is intended
to be enforceable by any entity that is not a Contributor or Recipient.
No third-party beneficiary rights are created under this Agreement.
Exhibit A - Form of Secondary Licenses Notice
"This Source Code may also be made available under the following
Secondary Licenses when the conditions for such availability set forth
in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
version(s), and exceptions or additional permissions here}."
Simply including a copy of this Agreement, including this Exhibit A
is not sufficient to license the Source Code under Secondary Licenses.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to
look for such a notice.
You may add additional accurate notices of copyright ownership.
Eclipse Distribution License - v 1.0
Copyright (c) 2007, Eclipse Foundation, Inc. and its licensors.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
Neither the name of the Eclipse Foundation, Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
cyclonedds-0.8.2/NOTICE.md 0000664 0000000 0000000 00000003056 14167046072 0015166 0 ustar 00root root 0000000 0000000 # Notices for Eclipse Cyclone DDS
This content is produced and maintained by the Eclipse Cyclone DDS project.
* Project home: https://projects.eclipse.org/projects/iot.cyclonedds
## Trademarks
Eclipse Cyclone DDS is a trademark of the Eclipse Foundation.
## Copyright
All content is the property of the respective authors or their employers. For
more information regarding authorship of content, please consult the listed
source code repository logs.
## Declared Project Licenses
This program and the accompanying materials are made available under the terms
of the Eclipse Public License v. 2.0 which is available at
http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License v. 1.0
which is available at http://www.eclipse.org/org/documents/edl-v10.php.
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
## Source Code
The project maintains the following source code repositories:
* https://github.com/eclipse/cyclonedds
## Third-party Content
libmd5-rfc (2002-04-13)
* License: Zlib
grammers-v4 (git SHA 6610e82ee235992f50e108cd59204f3bcd7128c1)
* License: New BSD License
getopt 1.5 (1998-03-11)
* License: Public domain
## Cryptography
Content may contain encryption software. The country in which you are currently
may have restrictions on the import, possession, and use, and/or re-export to
another country, of encryption software. BEFORE using any encryption software,
please check the country's laws, regulations and policies concerning the import,
possession, or use, and re-export of encryption software, to see if this is
permitted.
cyclonedds-0.8.2/PackageConfig.cmake.in 0000664 0000000 0000000 00000001314 14167046072 0017746 0 ustar 00root root 0000000 0000000 #
# Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
#
# This program and the accompanying materials are made available under the
# terms of the Eclipse Public License v. 2.0 which is available at
# http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
# v. 1.0 which is available at
# http://www.eclipse.org/org/documents/edl-v10.php.
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
@PACKAGE_INIT@
if(@CYCLONE_BUILD_WITH_ICEORYX@)
include(CMakeFindDependencyMacro)
find_dependency(iceoryx_binding_c)
endif()
include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
if(TARGET CycloneDDS::idlc)
include("${CMAKE_CURRENT_LIST_DIR}/idlc/Generate.cmake")
endif()
cyclonedds-0.8.2/README.md 0000664 0000000 0000000 00000033526 14167046072 0015147 0 ustar 00root root 0000000 0000000 [](https://dev.azure.com/eclipse-cyclonedds/cyclonedds/_build/latest?definitionId=4&branchName=master)
[](https://scan.coverity.com/projects/eclipse-cyclonedds-cyclonedds)
[](https://dev.azure.com/eclipse-cyclonedds/cyclonedds/_build/latest?definitionId=4&branchName=master)
[](https://choosealicense.com/licenses/epl-2.0/)
[](https://choosealicense.com/licenses/edl-1.0/)
# Eclipse Cyclone DDS
Eclipse Cyclone DDS is a very performant and robust open-source DDS implementation. Cyclone DDS is developed completely in the open as an Eclipse IoT project
(see [eclipse-cyclone-dds](https://projects.eclipse.org/projects/iot.cyclonedds)) with a growing list of [adopters](https://iot.eclipse.org/adopters/?#iot.cyclonedds) (if you're one of them, please add your [logo](https://github.com/EclipseFdn/iot.eclipse.org/issues/new?template=adopter_request.md)). It is a tier-1 middleware for the Robot Operating System [ROS 2](https://index.ros.org/doc/ros2/).
* [Getting Started](#getting-started)
* [Performance](#performance)
* [Configuration](#configuration)
> Consult the [roadmap](ROADMAP.md) for a high-level overview of upcoming features.
# Getting Started
## Building Eclipse Cyclone DDS
In order to build Cyclone DDS you need a Linux, Mac or Windows 10 machine (or, with some caveats, a *BSD, OpenIndiana or a Solaris 2.6 one) with the following installed on your host:
* C compiler (most commonly GCC on Linux, Visual Studio on Windows, Xcode on macOS);
* GIT version control system;
* [CMake](https://cmake.org/download/), version 3.7 or later;
* [OpenSSL](https://www.openssl.org/), preferably version 1.1 or later if you want to use TLS over
TCP. You can explicitly disable it by setting ``ENABLE_SSL=NO``, which is very useful for
reducing the footprint or when the FindOpenSSL CMake script gives you trouble;
* [Bison](https://www.gnu.org/software/bison/) parser generator.
On Ubuntu ``apt install bison`` should do the trick for getting Bison installed, and the rest should
already be there. On Windows, installing chocolatey and ``choco install winflexbison3`` should get
you a long way. On macOS, ``brew install bison`` is easiest.
To obtain Eclipse Cyclone DDS, do
$ git clone https://github.com/eclipse-cyclonedds/cyclonedds.git
$ cd cyclonedds
$ mkdir build
Depending on whether you want to develop applications using Cyclone DDS or contribute to it you can
follow different procedures
### For application developers
To build and install the required libraries needed to develop your own applications using Cyclone
DDS requires a few simple steps. There are some small differences between Linux and macOS on the one
hand, and Windows on the other. For Linux or macOS:
$ cd build
$ cmake -DCMAKE_INSTALL_PREFIX= -DBUILD_EXAMPLES=ON ..
$ cmake --build .
and for Windows:
$ cd build
$ cmake -G "" -DCMAKE_INSTALL_PREFIX= -DBUILD_EXAMPLES=ON ..
$ cmake --build .
where you should replace ```` by the directory under which you would like to
install Cyclone DDS and ```` by one of the ways
CMake [generators](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html) offer for
generating build files. For example, "Visual Studio 15 2017 Win64" would target a 64-bit build
using Visual Studio 2017.
To install it after a successful build, do:
$ cmake --build . --target install
which will copy everything to:
* ``/lib``
* ``/bin``
* ``/include/ddsc``
* ``/share/CycloneDDS``
Depending on the installation location you may need administrator privileges.
At this point you are ready to use Eclipse Cyclone DDS in your own projects.
Note that the default build type is a release build with debug information included
(RelWithDebInfo), which is generally the most convenient type of build to use from applications
because of a good mix between performance and still being able to debug things. If you'd rather
have a Debug or pure Release build, set ``CMAKE_BUILD_TYPE`` accordingly.
### Contributing to Eclipse Cyclone DDS
We very much welcome all contributions to the project, whether that is questions, examples, bug
fixes, enhancements or improvements to the documentation, or anything else really. When considering
contributing code, it might be good to know that build configurations for Travis CI and AppVeyor are
present in the repository and that there is a test suite using CTest and CUnit that can be built
locally if desired. To build it, set the cmake variable ``BUILD_TESTING`` to on when configuring, e.g.:
$ cd build
$ cmake -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON ..
$ cmake --build .
$ ctest
Such a build requires the presence of [CUnit](http://cunit.sourceforge.net/). You can install this
yourself, or you can choose to instead rely on the [Conan](https://conan.io) packaging system that
the CI build infrastructure also uses. In that case, install Conan and do:
$ conan install .. --build missing
in the build directory prior to running cmake.
For Windows, depending on the generator, you might also need to add switches to select the architecture
and build type, e.g., ``conan install -s arch=x86_64 -s build_type=Debug ..`` This will automatically
download and/or build CUnit (and, at the moment, OpenSSL).
## Documentation
The documentation is still rather limited, and at the moment only available in the sources (in the
form of restructured text files in ``docs`` and Doxygen comments in the header files), or as
a
[PDF](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/pdf/CycloneDDS-0.1.0.pdf). The
intent is to automate the process of building the documentation and have them available in more
convenient formats and in the usual locations.
## Building and Running the Roundtrip Example
We will show you how to build and run an example program that measures latency. The examples are
built automatically when you build Cyclone DDS, so you don't need to follow these steps to be able
to run the program, it is merely to illustrate the process.
$ mkdir roundtrip
$ cd roundtrip
$ cmake /share/CycloneDDS/examples/roundtrip
$ cmake --build .
On one terminal start the application that will be responding to pings:
$ ./RoundtripPong
On another terminal, start the application that will be sending the pings:
$ ./RoundtripPing 0 0 0
# payloadSize: 0 | numSamples: 0 | timeOut: 0
# Waiting for startup jitter to stabilise
# Warm up complete.
# Latency measurements (in us)
# Latency [us] Write-access time [us] Read-access time [us]
# Seconds Count median min 99% max Count median min Count median min
1 28065 17 16 23 87 28065 8 6 28065 1 0
2 28115 17 16 23 46 28115 8 6 28115 1 0
3 28381 17 16 22 46 28381 8 6 28381 1 0
4 27928 17 16 24 127 27928 8 6 27928 1 0
5 28427 17 16 20 47 28427 8 6 28427 1 0
6 27685 17 16 26 51 27685 8 6 27685 1 0
7 28391 17 16 23 47 28391 8 6 28391 1 0
8 27938 17 16 24 63 27938 8 6 27938 1 0
9 28242 17 16 24 132 28242 8 6 28242 1 0
10 28075 17 16 23 46 28075 8 6 28075 1 0
The numbers above were measured on Mac running a 4.2 GHz Intel Core i7 on December 12th 2018. From
these numbers you can see how the roundtrip is very stable and the minimal latency is now down to 17
micro-seconds (used to be 25 micro-seconds) on this HW.
# Performance
Reliable message throughput is over 1MS/s for very small samples and is roughly 90% of GbE with 100
byte samples, and latency is about 30us when measured using [ddsperf](src/tools/ddsperf) between two
Intel(R) Xeon(R) CPU E3-1270 V2 @ 3.50GHz (that's 2012 hardware ...) running Ubuntu 16.04, with the
executables built on Ubuntu 18.04 using gcc 7.4.0 for a default (i.e., "RelWithDebInfo") build.

This is with the subscriber in listener mode, using asynchronous delivery for the throughput
test. The configuration is a marginally tweaked out-of-the-box configuration: an increased maximum
message size and fragment size, and an increased high-water mark for the reliability window on the
writer side. For details, see the [scripts](examples/perfscript) directory,
the
[environment details](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/performance/20190730/config.txt) and
the
[throughput](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/performance/20190730/sub.log) and
[latency](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/performance/20190730/ping.log) data
underlying the graphs. These also include CPU usage ([throughput](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/performance/20190730/throughput-async-listener-cpu.png) and [latency](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/performance/20190730/latency-sync-listener-bwcpu.png)) and [memory usage](https://raw.githubusercontent.com/eclipse-cyclonedds/cyclonedds/assets/performance/20190730/throughput-async-listener-memory.png).
# Configuration
The out-of-the-box configuration should usually be fine, but there are a great many options that can
be tweaked by creating an XML file with the desired settings and defining the ``CYCLONEDDS_URI`` to
point to it. E.g. (on Linux):
$ cat cyclonedds.xml
auto
default
65500B
4000B
500kB
config
stdout
$ export CYCLONEDDS_URI=file://$PWD/cyclonedds.xml
(on Windows, one would have to use ``set CYCLONEDDS_URI=file://...`` instead.)
This example shows a few things:
* ``NetworkInterfaceAddress`` can be used to override the interface selected by default (you can use
the address or the interface name). Proper use of multiple network interfaces simultaneously will
come, but is not there yet.
* ``AllowMulticast`` configures the circumstances under which multicast will be used. If the
selected interface doesn't support it, it obviously won't be used (``false``); but if it does
support it, the type of the network adapter determines the default value. For a wired network, it
will use multicast for initial discovery as well as for data when there are multiple peers that
the data needs to go to (``true``); but on a WiFi network it will use it only for initial
discovery (``spdp``), because multicast on WiFi is very unreliable.
* ``Verbosity`` allows control over the tracing, "config" dumps the configuration to the trace
output (which defaults to "cyclonedds.log"). Which interface is used, what multicast settings are
used, etc., is all in the trace. Setting the verbosity to "finest" gives way more output on the
inner workings, and there are various other levels as well.
* ``MaxMessageSize`` and ``FragmentSize`` control the maximum size of the RTPS messages (basically
the size of the UDP payload), and the size of the fragments into which very large samples get
split (which needs to be "a bit" less). Large values such as these typically improve performance
over the (current) default values.
* ``WhcHigh`` determines when the sender will wait for acknowledgements from the readers because it
has buffered too much unacknowledged data. There is some auto-tuning, the (current) default value
is a bit small to get really high throughput.
Background information on configuring Cyclone DDS can be found
[here](docs/manual/config.rst) and a list of settings is
[available](docs/manual/options.md).
# Trademarks
* "Eclipse Cyclone DDS" and "Cyclone DDS" are trademarks of the Eclipse Foundation.
* "DDS" is a trademark of the Object Management Group, Inc.
* "ROS" is a trademark of Open Source Robotics Foundation, Inc.
cyclonedds-0.8.2/ROADMAP.md 0000664 0000000 0000000 00000004704 14167046072 0015271 0 ustar 00root root 0000000 0000000 # Cyclone DDS Roadmap
## Introduction
The Eclipse Cyclone DDS project aims at implementing the OMG DDS core standards, namely:
* [Data Distribution Service][1] (DDS)
* [DDS Interoperability Wire Protocol][2] (DDSI-RTPS)
* [DDS Security][3] (DDS-SECURITY)
* [Extensible and Dynamic Topic Types for DDS][1] (DDS-XTypes)
We ultimately aim to comply with the latest version of above OMG standards. Cyclone DDS supports currently the following language bindings for the DCPS APIs:
* C language
* C++ language ([ISO/IEC C++ 2003 Language PSM for DDS][5]) (DDS-PSM-Cxx)
The community is welcome to add new language bindings and contribute to the implementation of other OMG specifications.
The roadmap presented here is indicative and subject to change.
## Short-term milestones
**Cyclone 0.8**
* C++11 APIs (GA)
* New APIs to access to serialized CDR data
* New APIs for configuring the deployment of Cyclone DDS based application
* Multi-Network interface cards support (Consolidation)
* Content filtering support for C++
* IDL compiler front-end & back end support of the Xtypes annotations
* Topic and data type discovery
* ROS 2 Quality Level 2
* Automated performance and regression testing
* Formal feature list also showing test coverage
* APIs marked stable (each API in formal feature list), evolving or experimental
**Cyclone 0.9**
* Integration of Durability Service for Transient and Persistent data
* Shared memory transport support
* Python APIs (GA)
* Internet-scale deployment support
* DDS-Xtypes APIs
* Asynchronous mode of operation
* ROS 2 Quality Level 1
## Midterm milestones
**Cyclone 1.0**
* Static discovery
* Static memory allocation
* Writer side filtering support
* Content Querying APIs
## Long-term milestones
**Future versions**
* Network Mobility support
* C# language binding support (DDS C# API)
* Java language binding support (Java 5 Language PSM for DDS)
* Time-sensitive Networking support DDS-TSN
* Rust language binding support
* Certifiable DDS
* Face 3 support
* Network Scheduling and Federated architecture support
* [TrustZone](https://developer.arm.com/ip-products/security-ip/trustzone) support for DDS Security
[1]: https://www.omg.org/spec/DDS/About-DDS/
[2]: https://www.omg.org/spec/DDSI-RTPS/About-DDSI-RTPS/
[3]: https://www.omg.org/spec/DDS-SECURITY/About-DDS-SECURITY/
[4]: https://www.omg.org/spec/DDS-XTypes/About-DDS-XTypes/
[5]: https://www.omg.org/spec/DDS-PSM-Cxx/About-DDS-PSM-Cxx/
cyclonedds-0.8.2/WiX/ 0000775 0000000 0000000 00000000000 14167046072 0014366 5 ustar 00root root 0000000 0000000 cyclonedds-0.8.2/WiX/DialogOrder.wxs 0000664 0000000 0000000 00000011523 14167046072 0017326 0 ustar 00root root 0000000 0000000
1
"1"]]>
1
NOT Installed
Installed AND PATCH
1
LicenseAccepted = "1"
1
1
1
1
NOT WIXUI_DONTVALIDATEPATH
"1"]]>
WIXUI_DONTVALIDATEPATH OR WIXUI_INSTALLDIR_VALID="1"
1
1
NOT Installed
Installed AND NOT PATCH
Installed AND PATCH
1
1
1
1