Bond

Bond是一个用于处理模式化数据的跨平台框架。 它支持跨语言的de/serialization和强大的通用机制,可以有效地处理数据。 Bond广泛用于Microsoft的高规模服务。(Bond is a cross-platform framework for working with schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. Bond is broadly used at Microsoft in high scale services.)

  • 所有者: microsoft/bond
  • 平台: Linux, Mac, Windows
  • 許可證: MIT License
  • 分類:
  • 主題:
  • 喜歡:
    0
      比較:

Github星跟蹤圖

The Bond logo: a stylized glue gun

Build Status
Bond.CSharp NuGet package

Bond

Bond is an open-source, cross-platform framework for working with schematized
data. It supports cross-language serialization/deserialization and powerful
generic mechanisms for efficiently manipulating data. Bond is broadly used at
Microsoft in high scale services.

Bond is published on GitHub at https://github.com/microsoft/bond/.

For details, see the User's Manuals:

For a discussion about how Bond compares to similar frameworks see Why Bond.

Dependencies

Bond C++ library requires some C++11 features (currently limited to those
supported by Visual C++ 2013); a C++11 compiler is required. Additionally,
to build Bond you will need CMake (3.1+),
Haskell Stack
(1.5.1+) and Boost (1.61+).

Additionally, Bond requires RapidJSON and optionally requires gRPC. The Bond repository primarily uses Git submodules for these two dependencies. It should be cloned with the --recursive flag:

git clone --recursive https://github.com/microsoft/bond.git

If you already have RapidJSON and would like to build against it, add argument -DBOND_FIND_RAPIDJSON=TRUE to the CMake invocation. It will use find_package(RapidJSON). If you do not provide a RapidJSON library, Bond will also install RapidJSON.

If you do not wish to build the gRPC component, add argument -DBOND_ENABLE_GRPC=FALSE to the CMake invocation.

Following are specific instructions for building on various platforms.

Linux

Bond must be built with C++11 compiler. We test with Clang (3.8) and GNU C++
(5.4). We recommend Clang as it's faster with template-heavy code like Bond.

Run the following commands to install the minimal set of packages needed to
build the core Bond library on Ubuntu 14.04:

sudo apt-get install \
    clang \
    cmake \
    zlib1g-dev \
    libboost-dev \
    libboost-thread-dev

Additionally, you need the Haskell Tool
Stack
. If your distro isn't
shipping a new enough version of it, you may encounter some non-obvious build
failures, so we recommend installing the latest Stack outside of package
management:

curl -sSL https://get.haskellstack.org/, sh

In the root bond directory run:

mkdir build
cd build
cmake -DBOND_ENABLE_GRPC=FALSE ..
make
sudo make install

The build directory is just an example. Any directory can be used as the
build destination.

To build the Bond Python module, all the C++/Python tests and
examples, and Bond-over-gRPC, a few more packages are needed.

sudo apt-get install \
    autoconf \
    build-essential \
    golang \
    libboost-date-time-dev \
    libboost-python-dev \
    libboost-test-dev \
    libtool \
    python2.7-dev

CMake needs to be re-run with different options. This can be done after
building just the core libraries: the build tree will simply be updated with
the new options.

cd build # or wherever you ran CMake before
cmake -DBOND_ENABLE_GRPC=TRUE -DgRPC_ZLIB_PROVIDER=package ..

Running the following command in the build directory will build and execute all
the tests and examples:

make --jobs 8 check
sudo make install # To install the other libraries just built

(The unit tests are large so you may want to run 4-8 build jobs in parallel,
assuming you have enough memory.)

macOS

Install Xcode and then run the following command to install the required
packages using Homebrew (http://brew.sh/):

brew install \
    cmake \
    haskell-stack \
    boost \
    boost-python

(boost-python is optional and only needed for Python support.)

Bond can be built on macOS using either standard *nix makefiles or Xcode. In
order to generate and build from makefiles, in the root bond directory run:

mkdir build
cd build
cmake -DBOND_ENABLE_GRPC=FALSE ..
make
sudo make install

Alternatively, you can generate Xcode projects by passing the -G Xcode option
to cmake:

cmake -DBOND_ENABLE_GRPC=FALSE -G Xcode ..

You can build and run unit tests by building the check target in Xcode or by
running make in the build directory:

make --jobs 8 check

Note that if you are using Homebrew's Python, you'll need to build
boost-python from source:

brew install --build-from-source boost-python

and tell cmake the location of Homebrew's libpython by setting the
PYTHON_LIBRARY variable, e.g.:

cmake .. \
    -DPYTHON_LIBRARY=/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib

Windows

Build Status

Install the following tools:

If you are building on a network behind a proxy, set the environment variable
HTTP_PROXY, e.g.:

set HTTP_PROXY=http://your-proxy-name:80

Now you are ready to build the C# version of Bond. Open the solution file
cs\cs.sln in Visual Studio and build as usual. The C# unit tests can
also be run from within the solution.

To build using the .NET Core SDK:

dotnet restore cs\cs.sln
dotnet msbuild cs\cs.sln

The C++ and Python versions of Bond additionally require:

You may need to set the environment variables BOOST_ROOT and BOOST_LIBRARYDIR
to specify where Boost and its pre-built libraries for your environment (MSVC 12 or MSVC 14) can be
found, e.g.:

set BOOST_ROOT=D:\boost_1_61_0
set BOOST_LIBRARYDIR=D:\boost_1_61_0\lib64-msvc-14.0

The core Bond library and most examples only require Boost headers. The
pre-built libraries are only needed for unit tests, Python, and gRPC
support. If Boost or Python libraries are not found on the system, then some
tests and examples will not be built.

To generate a solution to build the Bond Core C++ and Python with Visual
Studio 2015 run the following commands from the root bond directory:

mkdir build
cd build
set PreferredToolArchitecture=x64
cmake -DBOND_ENABLE_GRPC=FALSE -G "Visual Studio 14 2015 Win64" ..

Setting PreferredToolArchitecture=x64 selects the 64-bit toolchain which
dramatically improves build speed. (The Bond unit tests are too big to build
with 32-bit tools.)

Instead of cmake you can also use cmake-gui and specify configuration
settings in the UI. This configuration step has to be performed only once. From
then on you can use the generated solution build\bond.sln from Visual Studio
or build from the command line using cmake:

cmake --build . --target
cmake --build . --target INSTALL

To build and execute the unit tests and examples run:

cmake --build . --target check -- /maxcpucount:8

To build Bond's gRPC++ integration from source, some of
gRPC's prerequisites
are also needed:

choco install activeperl golang ninja yasm

You will also need to enable gRPC in the cmake configuration step by running the following
in the build directory from above and then following the other cmake commands above:

cmake -DBOND_ENABLE_GRPC=TRUE -G "Visual Studio 14 2015 Win64" ..

Contributing

Interested in contributing to Bond? Take a look at our
contribution guidelines
to get started.

主要指標

概覽
名稱與所有者microsoft/bond
主編程語言C++
編程語言CMake (語言數: 12)
平台Linux, Mac, Windows
許可證MIT License
所有者活动
創建於2014-12-15 01:05:31
推送於2025-04-01 04:37:42
最后一次提交2025-03-31 21:37:44
發布數38
最新版本名稱13.0.1 (發布於 )
第一版名稱4.0.1 (發布於 2015-12-09 15:31:35)
用户参与
星數2.6k
關注者數193
派生數332
提交數1.4k
已啟用問題?
問題數456
打開的問題數139
拉請求數536
打開的拉請求數2
關閉的拉請求數213
项目设置
已啟用Wiki?
已存檔?
是復刻?
已鎖定?
是鏡像?
是私有?