FoundationDB - the open source, distributed, transactional key-value store
FoundationDB is a distributed database designed to handle large volumes of structured data across clusters of commodity servers. It organizes data as an ordered key-value store and employs ACID transactions for all operations. It is especially well-suited for read/write workloads but also has excellent performance for write-intensive workloads. Users interact with the database using API language binding.
To learn more about FoundationDB, visit foundationdb.org
Documentation can be found online at https://apple.github.io/foundationdb/. The documentation covers details of API usage, background information on design philosophy, and extensive usage examples. Docs are built from the source in this repo.
The FoundationDB Forums are the home for most of the discussion and communication about the FoundationDB project. We welcome your participation! We want FoundationDB to be a great project to be a part of and, as part of that, have established a Code of Conduct to establish what constitutes permissible modes of interaction.
Contributing to FoundationDB can be in contributions to the code base, sharing your experience and insights in the community on the Forums, or contributing to projects that make use of FoundationDB. Please see the contributing guide for more specifics.
Developers interested in using FoundationDB can get started by downloading and installing a binary package. Please see the downloads page for a list of available packages.
Developers on an OS for which there is no binary package, or who would like to start hacking on the code, can get started by compiling from source.dedicated repository..
To build outside the official docker image you'll need at least these dependencies:
If compiling for local development, please set
-DUSE_WERROR=ONin cmake. Our CI compiles with
-Werroron, so this way you'll find out about compiler warnings that break the build earlier.
Once you have your dependencies, you can run cmake and then build:
cmake -G Ninja
ninja # If this crashes it probably ran out of memory. Try ninja -j1
The language bindings that are supported by cmake will have a corresponding
README.mdfile in the corresponding
Generally, cmake will build all language bindings for which it can find all necessary dependencies. After each successful cmake run, cmake will tell you which language bindings it is going to build.
CMake can build a compilation database for you. However, the default generated one is not too useful as it operates on the generated files. When running make, the build system will create another
compile_commands.jsonfile in the source directory. This can than be used for tools like CCLS, CQuery, etc. This way you can get code-completion and code navigation in flow. It is not yet perfect (it will show a few errors) but we are constantly working on improving the development experience.
CMake will not produce a
compile_commands.json, you must pass
-DCMAKE_EXPORT_COMPILE_COMMANDS=ON. This also enables the target
processed_compile_commands, which rewrites
compile_commands.jsonto describe the actor compiler source file, not the post-processed output files, and places the output file in the source directory. This file should then be picked up automatically by any tooling.
Note that if building inside of the
foundationdb/builddocker image, the resulting paths will still be incorrect and require manual fixing. One will wish to re-run
-DCMAKE_EXPORT_COMPILE_COMMANDS=OFFto prevent it from reverting the manual changes.
CMake has built in support for a number of popular IDEs. However, because flow files are precompiled with the actor compiler, an IDE will not be very useful as a user will only be presented with the generated code - which is not what she wants to edit and get IDE features for.
The good news is, that it is possible to generate project files for editing flow with a supported IDE. There is a CMake option called
OPEN_FOR_IDEwhich will generate a project which can be opened in an IDE for editing. You won't be able to build this project, but you will be able to edit the files and get most edit and navigation features your IDE supports.
For example, if you want to use XCode to make changes to FoundationDB you can create a XCode-project with the following command:
cmake -G Xcode -DOPEN_FOR_IDE=ON
You should create a second build-directory which you will use for building and debugging.
Build from source.
sudo pkg install -r FreeBSD \ shells/bash devel/cmake devel/ninja devel/ccache \ lang/mono lang/python3 \ devel/boost-libs devel/libeio \ security/openssl mkdir .build && cd .build cmake -G Ninja \ -DUSE_CCACHE=on \ -DDISABLE_TLS=off \ -DUSE_DTRACE=off \ .. ninja -j 10 # run fast tests ctest -L fast # run all tests ctest --output-on-failure -v
There are no special requirements for Linux. A docker image can be pulled from
foundationdb/buildthat has all of FoundationDB's dependencies pre-installed, and is what the CI uses to build and test PRs.
cmake -G Ninja ninja cpack -G DEB
For RPM simply replace
The build under MacOS will work the same way as on Linux. To get boost and ninja you can use Homebrew.
cmake -G Ninja
To generate a installable package,
ninja $SRCDIR/packaging/osx/buildpkg.sh . $SRCDIR
Under Windows, the build instructions are very similar, with the main difference that Visual Studio is used to compile.
JAVA_HOMEto the unpacked location and JAVACOMPILE to `$JAVAHOME/bin/javac`.
cmake -G "Visual Studio 15 2017 Win64" -DBOOST_ROOT=
msbuild /p:Configuration=Release foundationdb.sln. You can also open the resulting solution in Visual Studio and compile from there. However, be aware that using Visual Studio for development is currently not supported as Visual Studio will only know about the generated files.
msbuildis located at
c:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exefor Visual Studio 15.
If you installed WIX before running
cmakeyou should find the
FDBInstaller.msiin your build directory under
TODO: Re-add instructions for TLS support #3022