@myrepo//my/app/main:app_binary

load("//foo/bar:file.bzl", "some_library")

# I need a config file from a directory named env:
java_binary(
    name = "setenv",
    ...
    data = [":env/default_env.txt"],
)

# I need test data from another directory
sh_test(
    name = "regtest",
    srcs = ["regtest.sh"],
    data = [
        "//data:file1.txt",
        "//data:file2.txt",
        ...
    ],
)

workspace(name = "debug")

load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
load("//bazel:go_deps.bzl", "go_dependencies")

# gazelle:repository_macro bazel/go_deps.bzl%go_dependencies
go_dependencies()

load("@io_bazel_rules_docker//repositories:deps.bzl", rules_docker_go_deps = "deps")

rules_docker_go_deps()  

build --java_runtime_version=remotejdk_11

build --host_force_python=PY3
build --python_version=PY3

build --cxxopt=-std=c++17

build --experimental_cc_shared_library
build --experimental_link_static_libraries_once

# This is to avoid building both PIC and non-PIC versions in opt mode,
# which doubles the build time.
build --force_pic

build:release --copt="-g1" --copt="-flto=thin"

<workspace-name>/                         <== workspace文件路径
  bazel-my-project => <...my-project>     <== Symlink to execRoot
  bazel-out => <...bin>                   <== Convenience symlink to outputPath
  bazel-bin => <...bin>                   <== Convenience symlink to most recent written bin dir $(BINDIR)
  bazel-testlogs => <...testlogs>         <== Convenience symlink to the test logs directory

/home/user/.cache/bazel/                  <== Root for all Bazel output on a machine: outputRoot
  _bazel_$USER/                           <== Top level directory for a given user depends on the user name:
                                              outputUserRoot
    install/
      fba9a2c87ee9589d72889caf082f1029/   <== Hash of the Bazel install manifest: installBase
        _embedded_binaries/               <== Contains binaries and scripts unpacked from the data section of
                                              the bazel executable on first run (such as helper scripts and the
                                              main Java file BazelServer_deploy.jar)
    7ffd56a6e4cb724ea575aba15733d113/     <== Hash of the client's workspace directory (such as
                                              /home/user/src/my-project): outputBase
      action_cache/                       <== Action cache directory hierarchy
                                              This contains the persistent record of the file
                                              metadata (timestamps, and perhaps eventually also MD5
                                              sums) used by the FilesystemValueChecker.
      action_outs/                        <== Action output directory. This contains a file with the
                                              stdout/stderr for every action from the most recent
                                              bazel run that produced output.
      command.log                         <== A copy of the stdout/stderr output from the most
                                              recent bazel command.
      external/                           <== The directory that remote repositories are
                                              downloaded/symlinked into.
      server/                             <== The Bazel server puts all server-related files (such
                                              as socket file, logs, etc) here.
        jvm.out                           <== The debugging output for the server.
      execroot/                           <== The working directory for all actions. For special
                                              cases such as sandboxing and remote execution, the
                                              actions run in a directory that mimics execroot.
                                              Implementation details, such as where the directories
                                              are created, are intentionally hidden from the action.
                                              Every action can access its inputs and outputs relative
                                              to the execroot directory.
        <workspace-name>/                 <== Working tree for the Bazel build & root of symlink forest: execRoot
          _bin/                           <== Helper tools are linked from or copied to here.

          bazel-out/                      <== All actual output of the build is under here: outputPath
            local_linux-fastbuild/        <== one subdirectory per unique target BuildConfiguration instance;
                                              this is currently encoded
              bin/                        <== Bazel outputs binaries for target configuration here: $(BINDIR)
                foo/bar/_objs/baz/        <== Object files for a cc_* rule named //foo/bar:baz
                  foo/bar/baz1.o          <== Object files from source //foo/bar:baz1.cc
                  other_package/other.o   <== Object files from source //other_package:other.cc
                foo/bar/baz               <== foo/bar/baz might be the artifact generated by a cc_binary named
                                              //foo/bar:baz
                foo/bar/baz.runfiles/     <== The runfiles symlink farm for the //foo/bar:baz executable.
                  MANIFEST
                  <workspace-name>/
                    ...
              genfiles/                   <== Bazel puts generated source for the target configuration here:
                                              $(GENDIR)
                foo/bar.h                     such as foo/bar.h might be a headerfile generated by //foo:bargen
              testlogs/                   <== Bazel internal test runner puts test log files here
                foo/bartest.log               such as foo/bar.log might be an output of the //foo:bartest test with
                foo/bartest.status            foo/bartest.status containing exit status of the test (such as
                                              PASSED or FAILED (Exit 1), etc)
              include/                    <== a tree with include symlinks, generated as needed. The
                                              bazel-include symlinks point to here. This is used for
                                              linkstamp stuff, etc.
            host/                         <== BuildConfiguration for build host (user's workstation), for
                                              building prerequisite tools, that will be used in later stages
                                              of the build (ex: Protocol Compiler)
        <packages>/                       <== Packages referenced in the build appear as if under a regular workspace

workspace(name = "cyber_security")

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

# portable llvm toolchain

BAZEL_TOOLCHAIN_TAG = "0.8.2"
BAZEL_TOOLCHAIN_SHA = "0fc3a2b0c9c929920f4bed8f2b446a8274cad41f5ee823fd3faa0d7641f20db0"

http_archive(
    name = "com_grail_bazel_toolchain",
    sha256 = BAZEL_TOOLCHAIN_SHA,
    strip_prefix = "bazel-toolchain-{tag}".format(tag = BAZEL_TOOLCHAIN_TAG),
    canonical_id = BAZEL_TOOLCHAIN_TAG,
    url = "https://github.com/grailbio/bazel-toolchain/archive/refs/tags/{tag}.tar.gz".format(tag = BAZEL_TOOLCHAIN_TAG),
)

load("@com_grail_bazel_toolchain//toolchain:deps.bzl", "bazel_toolchain_dependencies")

bazel_toolchain_dependencies()

load("@com_grail_bazel_toolchain//toolchain:rules.bzl", "llvm_toolchain")

llvm_toolchain(
    name = "llvm_toolchain",
    llvm_version = "15.0.0",
)

load("@llvm_toolchain//:toolchains.bzl", "llvm_register_toolchains")

llvm_register_toolchains()

# protobuf and grpc section
# http_archive(
#     name = "rules_proto",
#     sha256 = "dc3fb206a2cb3441b485eb1e423165b231235a1ea9b031b4433cf7bc1fa460dd",
#     strip_prefix = "rules_proto-5.3.0-21.7",
#     urls = [
#         "https://github.com/bazelbuild/rules_proto/archive/refs/tags/5.3.0-21.7.tar.gz",
#     ],
# )
# load("@rules_proto//proto:repositories.bzl", "rules_proto_dependencies", "rules_proto_toolchains")
# rules_proto_dependencies()
# rules_proto_toolchains()

http_archive(
    name = "com_github_grpc_grpc",
    strip_prefix = "grpc-1.57.0",
    sha256 = "8393767af531b2d0549a4c26cf8ba1f665b16c16fb6c9238a7755e45444881dd",
    urls = ["https://github.com/grpc/grpc/archive/refs/tags/v1.57.0.tar.gz"],
)
 
load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")
grpc_deps()
 
load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps")
grpc_extra_deps()

# experimental/sync_grpc_server/protos/stream.proto
syntax="proto3";

package stream;

// The service definition.
service Parser {
  // Sends a request
  rpc SendRequest (Request) returns (Response) {}
}

message Request {
    bytes client_ip = 1;
}

message Response {
    bytes event_id = 1;
}

# experimental/sync_grpc_server/protos/BUILD
```starlark
package(default_visibility = ["//visibility:public"])

load("@rules_proto//proto:defs.bzl", "proto_library")
load("@rules_cc//cc:defs.bzl", "cc_proto_library")
load("@com_github_grpc_grpc//bazel:cc_grpc_library.bzl", "cc_grpc_library")

# The following three rules demonstrate the usage of the cc_grpc_library rule in
# in a mode compatible with the native proto_library and cc_proto_library rules.
proto_library(
    name = "stream_proto",
    srcs = ["stream.proto"],
)

cc_proto_library(
    name = "stream_cc_proto",
    deps = [":stream_proto"],
)

cc_grpc_library(
    name = "stream_cc_grpc",
    srcs = [":stream_proto"],
    grpc_only = True,
    deps = [":stream_cc_proto"],
)

```

#experimental/sync_grpc_server/src/sync_client.cc
```cpp
#include <iostream>
#include <memory>
#include <string>

#include "grpcpp/grpcpp.h"

#ifdef BAZEL_BUILD
#include "experimental/sync_grpc_server/protos/stream.grpc.pb.h"
#else
#include "stream.grpc.pb.h"
#endif

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using stream::Parser;
using stream::Response;
using stream::Request;

class ParserClient {
 public:
  ParserClient(std::shared_ptr<Channel> channel)
      : stub_(Parser::NewStub(channel)) {}

  // Assembles the client's payload, sends it and presents the response back
  // from the server.
  std::string SendRequest() {
    // Data we are sending to the server.
    Request request;
    request.set_client_ip("127.0.0.1");

    // Container for the data we expect from the server.
    Response response;

    // Context for the client. It could be used to convey extra information to
    // the server and/or tweak certain RPC behaviors.
    ClientContext context;

    // The actual RPC.
    Status status = stub_->SendRequest(&context, request, &response);

    // Act upon its status.
    if (status.ok()) {
      return std::string(response.event_id());
    } else {
      std::cout << status.error_code() << ": " << status.error_message() << std::endl;
      return "RPC failed";
    }
  }

 private:
  std::unique_ptr<Parser::Stub> stub_;
};

int main(int argc, char** argv) {
  std::string address = "localhost";
  std::string port = "50051";
  std::string server_address = address + ":" + port;
  std::cout << "Client querying server address: " << server_address << std::endl;


  // Instantiate the client. It requires a channel, out of which the actual RPCs
  // are created. This channel models a connection to an endpoint (in this case,
  // localhost at port 50051). We indicate that the channel isn't authenticated
  // (use of InsecureChannelCredentials()).
  ParserClient Parser(grpc::CreateChannel(
      server_address, grpc::InsecureChannelCredentials()));

  std::string response = Parser.SendRequest();
  std::cout << "Parser received: " << response << std::endl;

  return 0;
}
```
#experimental/sync_grpc_server/src/sync_server.cc
```cpp
#include <iostream>
#include <memory>
#include <string>

#include <grpcpp/grpcpp.h>

#ifdef BAZEL_BUILD
#include "experimental/sync_grpc_server/protos/stream.grpc.pb.h"
#else
#include "stream.grpc.pb.h"
#endif

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using stream::Request;
using stream::Response;
using stream::Parser;

// Logic and data behind the server's behavior.
class ParserServiceImpl final : public Parser::Service {
  Status SendRequest(ServerContext* context, const Request* request,
                  Response* response) override {
    response->set_event_id("47F1F2FF-7679-4378-ACC7-051F72D5679A");
    return Status::OK;
  }
};

void RunServer() {
  std::string address = "0.0.0.0";
  std::string port = "50051";
  std::string server_address = address + ":" + port;
  ParserServiceImpl service;

  ServerBuilder builder;
  // Listen on the given address without any authentication mechanism.
  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
  // Register "service" as the instance through which we'll communicate with
  // clients. In this case it corresponds to an *synchronous* service.
  builder.RegisterService(&service);
  // Finally assemble the server.
  std::unique_ptr<Server> server(builder.BuildAndStart());
  std::cout << "Server listening on " << server_address << std::endl;

  // Wait for the server to shutdown. Note that some other thread must be
  // responsible for shutting down the server for this call to ever return.
  server->Wait();
}

int main(int argc, char** argv) {
  RunServer();

  return 0;
}
```
#experimental/sync_grpc_server/src/BUILD
```starlark
package(default_visibility = ["//visibility:public"])

load("@rules_cc//cc:defs.bzl", "cc_binary")

cc_binary(
    name = "sync_client",
    srcs = ["sync_client.cc"],
    defines = ["BAZEL_BUILD"],
    deps = [
        "//experimental/sync_grpc_server/protos:stream_cc_grpc",
        "@com_github_grpc_grpc//:grpc++",
    ],
)

cc_binary(
    name = "sync_server",
    srcs = ["sync_server.cc"],
    defines = ["BAZEL_BUILD"],
    deps = [
        "//experimental/sync_grpc_server/protos:stream_cc_grpc",
        "@com_github_grpc_grpc//:grpc++",
    ],
)
```

# 窗口1 运行server
bazel run experimental/sync_grpc_server/src:sync_server

# 窗口2 运行client
bazel run experimental/sync_grpc_server/src:sync_client

#输出结果
➜  cyber_security git:(main) bazel run experimental/sync_grpc_server/src:sync_client
INFO: Analyzed target //experimental/sync_grpc_server/src:sync_client (0 packages loaded, 0 targets configured).
INFO: Found 1 target...
Target //experimental/sync_grpc_server/src:sync_client up-to-date:
  bazel-bin/experimental/sync_grpc_server/src/sync_client
INFO: Elapsed time: 0.168s, Critical Path: 0.00s
INFO: 1 process: 1 internal.
INFO: Build completed successfully, 1 total action
INFO: Running command line: bazel-bin/experimental/sync_grpc_server/src/sync_client
Client querying server address: localhost:50051
Parser received: 47F1F2FF-7679-4378-ACC7-051F72D5679A

cc_import(
  name = "mylib",
  hdrs = ["mylib.h"],
  static_library = "libmylib.a",
  # If alwayslink is turned on,
  # libmylib.a will be forcely linked into any binary that depends on it.
  # alwayslink = 1,
)

cc_library(
    name = "my_library",
    srcs = ["file1.cpp", "file2.cpp"],
    hdrs = ["header1.h", "header2.h"],
    visibility = ["//visibility:public"],
    deps = ["//path/to/dependency"],
    defines = ["DEBUG"],
    copts = ["-Wall", "-O2"],
)

cc_binary(
    name = "my_binary",
    srcs = ["main.cpp", "util.cpp"],
    hdrs = ["util.h"],
    visibility = ["//visibility:public"],
    deps = ["//path/to/dependency"],
    copts = ["-Wall", "-O2"],
)

bazel run //path/to/package:my_binary

cc_test(
    name = "my_test",
    srcs = ["test.cpp", "util.cpp"],
    hdrs = ["util.h"],
    visibility = ["//visibility:public"],
    deps = ["//path/to/dependency"],
    size = "small",
    copts = ["-Wall", "-O2"],
)

bazel test //path/to/package:my_test

load("//bazel:cpplint.bzl", "cpplint")
load("//bazel:rules_cc.bzl", "cc_library", "cc_test")

package(default_visibility = ["//visibility:public"])

cc_library(
    name = "file_debug",
    srcs = ["file_debug.cc"],
    hdrs = ["file_debug.h"],
    deps = [
        "@boost//:filesystem",
        "@com_github_google_glog//:glog",
        "@com_google_absl//absl/strings",
        "@com_google_absl//absl/strings:str_format",
        "@com_googlesource_code_re2//:re2",
    ],
)

filegroup(
    name = "file_pointer_file",
    # only two mock file pointer file, will never add new, so use glob
    srcs = glob([
        "*.txt",
    ]),
)

cc_test(
    name = "file_debug_test",
    srcs = [
        "file_debug_test.cc",
    ],
    data = [
        ":file_pointer_file",
    ],
    deps = [
        ":file_debug",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
)

cpplint()

git clone https://github.com/bazelbuild/examples

examples
└── cpp-tutorial
    ├──stage1
    │  ├── main
    │  │   ├── BUILD
    │  │   └── hello-world.cc
    │  └── WORKSPACE
    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE
    └──stage3
       ├── main
       │   ├── BUILD
       │   ├── hello-world.cc
       │   ├── hello-greet.cc
       │   └── hello-greet.h
       ├── lib
       │   ├── BUILD
       │   ├── hello-time.cc
       │   └── hello-time.h
       └── WORKSPACE

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
)

examples
└── cpp-tutorial
    └──stage1
       ├── main
       │   ├── BUILD
       │   └── hello-world.cc
       └── WORKSPACE

cd cpp-tutorial/stage1

bazel build //main:hello-world

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.267s, Critical Path: 0.25s

bazel-bin/main/hello-world

    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
    ],
)

cd ../stage2

bazel build //main:hello-world

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.399s, Critical Path: 0.30s

bazel-bin/main/hello-world

└──stage3
   ├── main
   │   ├── BUILD
   │   ├── hello-world.cc
   │   ├── hello-greet.cc
   │   └── hello-greet.h
   ├── lib
   │   ├── BUILD
   │   ├── hello-time.cc
   │   └── hello-time.h
   └── WORKSPACE

cc_library(
    name = "hello-time",
    srcs = ["hello-time.cc"],
    hdrs = ["hello-time.h"],
    visibility = ["//main:__pkg__"],
)

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
        "//lib:hello-time",
    ],
)

cd  ../stage3

bazel build //main:hello-world

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 0.167s, Critical Path: 0.00s

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

# Boost
# Famous C++ library that has given rise to many new additions to the C++ Standard Library
# Makes @boost available for use: For example, add `@boost//:algorithm` to your deps.
# For more, see https://github.com/nelhage/rules_boost and https://www.boost.org
http_archive(
    name = "com_github_nelhage_rules_boost",

    # Replace the commit hash in both places (below) with the latest, rather than using the stale one here.
    # Even better, set up Renovate and let it do the work for you (see "Suggestion: Updates" in the README).
    url = "https://github.com/nelhage/rules_boost/archive/96e9b631f104b43a53c21c87b01ac538ad6f3b48.tar.gz",
    strip_prefix = "rules_boost-96e9b631f104b43a53c21c87b01ac538ad6f3b48",
    # When you first run this tool, it'll recommend a sha256 hash to put here with a message like: "DEBUG: Rule 'com_github_nelhage_rules_boost' indicated that a canonical reproducible form can be obtained by modifying arguments sha256 = ..."
)
load("@com_github_nelhage_rules_boost//:boost/boost.bzl", "boost_deps")
boost_deps()

sudo apt-get update \
    && sudo apt-get -y install --no-install-recommends \
    autoconf \
    automake \
    libtool \
    libssl-dev

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

http_archive(
    name = "com_github_storypku_rules_folly",
    sha256 = "16441df2d454a6d7ef4da38d4e5fada9913d1f9a3b2015b9fe792081082d2a65",
    strip_prefix = "rules_folly-0.2.0",
    urls = [
        "https://github.com/storypku/rules_folly/archive/v0.2.0.tar.gz",
    ],
)

load("@com_github_storypku_rules_folly//bazel:folly_deps.bzl", "folly_deps")
folly_deps()

load("@com_github_nelhage_rules_boost//:boost/boost.bzl", "boost_deps")
boost_deps()

# Hiredis requires C99
SET(CMAKE_C_STANDARD 99)    #C99标准，添加到copt里面即可
SET(CMAKE_POSITION_INDEPENDENT_CODE ON)    #fpic标记，编译静态库时需要加上，这样子才能生成的静态库被第三方引用
SET(CMAKE_DEBUG_POSTFIX d)

SET(hiredis_sources   #下面的.c文件对应于bazel src文件，我们可以看到目前的代码实际上是包含sync和async的，
    alloc.c
    async.c
    dict.c
    hiredis.c
    net.c
    read.c
    sds.c
    sockcompat.c)

SET(hiredis_sources ${hiredis_sources})

...

ADD_LIBRARY(hiredis SHARED ${hiredis_sources})     #要生成这两个库文件
ADD_LIBRARY(hiredis_static STATIC ${hiredis_sources})

SET_TARGET_PROPERTIES(hiredis
    PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE
    VERSION "${HIREDIS_SONAME}")
SET_TARGET_PROPERTIES(hiredis_static
    PROPERTIES COMPILE_PDB_NAME hiredis_static)
SET_TARGET_PROPERTIES(hiredis_static
    PROPERTIES COMPILE_PDB_NAME_DEBUG hiredis_static${CMAKE_DEBUG_POSTFIX})


#INSTALL_INTERFACE用于给install的时候指定使用的引用文件，那么INSTALL_INTERFACE又是怎么指定的？看这个https://ravenxrz.ink/archives/e40194d1.html
TARGET_INCLUDE_DIRECTORIES(hiredis PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
TARGET_INCLUDE_DIRECTORIES(hiredis_static PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)

#CONFIGURE_FILE替换原本的普通文件的内容，给pkg用的，不需要了，所以去掉
CONFIGURE_FILE(hiredis.pc.in hiredis.pc @ONLY)

...

#Cpack打包的内容，直接省略了，关系并不大
...

IF(ENABLE_SSL)
    IF (NOT OPENSSL_ROOT_DIR)  #这个是export的openssl根目录，用来判断找openssl
        IF (APPLE)
            SET(OPENSSL_ROOT_DIR "/usr/local/opt/openssl")
        ENDIF()
    ENDIF()
    FIND_PACKAGE(OpenSSL REQUIRED)  #找到依赖的openssl库
    SET(hiredis_ssl_sources         #编译hiredis_ssl库的源文件
        ssl.c)
    ADD_LIBRARY(hiredis_ssl SHARED  
            ${hiredis_ssl_sources}) #设定生成的库文件
    ADD_LIBRARY(hiredis_ssl_static STATIC
            ${hiredis_ssl_sources})

	...

    SET_TARGET_PROPERTIES(hiredis_ssl_static
        PROPERTIES COMPILE_PDB_NAME hiredis_ssl_static)
    SET_TARGET_PROPERTIES(hiredis_ssl_static
        PROPERTIES COMPILE_PDB_NAME_DEBUG hiredis_ssl_static${CMAKE_DEBUG_POSTFIX})

    TARGET_INCLUDE_DIRECTORIES(hiredis_ssl PRIVATE "${OPENSSL_INCLUDE_DIR}")  #引入openssl包裹的头文件，只给自己用。不会暴露给hiredis_ssl的使用者
    TARGET_INCLUDE_DIRECTORIES(hiredis_ssl_static PRIVATE "${OPENSSL_INCLUDE_DIR}")

    TARGET_LINK_LIBRARIES(hiredis_ssl PRIVATE ${OPENSSL_LIBRARIES})
...

    INSTALL(TARGETS hiredis_ssl hiredis_ssl_static
        EXPORT hiredis_ssl-targets
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}    #安装bin文件的位置
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}    #安装动态库的位置
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})   #安装静态库的位置

...

    INSTALL(FILES hiredis_ssl.h   
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/hiredis)        #可以看到安装头文件的位置，将hiredis_ssl.h搞到了安装头文件hiredis里面

    INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl.pc    #提供给pkg安装用的，不用关注
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

    export(EXPORT hiredis_ssl-targets
           FILE "${CMAKE_CURRENT_BINARY_DIR}/hiredis_ssl-targets.cmake"
           NAMESPACE hiredis::)

    SET(CMAKE_CONF_INSTALL_DIR share/hiredis_ssl)
    ...
ENDIF()

...

cc_library(
    name = "hiredis",
    srcs = [
        "alloc.c",
        "dict.c",
        "async.c",
        "hiredis.c",
        "net.c",
        "read.c",
        "sds.c",
        "sockcompat.c",
    ],
    hdrs = glob(["*.h"])+glob(["adapters/*.h"])+["dict.c",],  #dict.c的引入是因为被async.c引了，而adapters是编译async时候别的库要使用
    include_prefix = "hiredis",
    visibility = ["//visibility:public"],
)

workspace(name = "cmake2bazel")

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

http_archive(
   name = "rules_foreign_cc",
   strip_prefix = "rules_foreign_cc-4010620160e0df4d894b61496d3d3b6fc8323212",
    sha256 = "07e3414cc841b1f4d16e5231eb818e5c5e03e2045827f5306a55709e5045c7fd",
   url = "https://github.com/bazelbuild/rules_foreign_cc/archive/4010620160e0df4d894b61496d3d3b6fc8323212.zip",
)

load("@rules_foreign_cc//foreign_cc:repositories.bzl", "rules_foreign_cc_dependencies")
rules_foreign_cc_dependencies()

all_content = """filegroup(name = "all", srcs = glob(["**"]), visibility = ["//visibility:public"])"""

# openssl
http_archive(
    name = "openssl",
    build_file_content = all_content,
    strip_prefix = "openssl-OpenSSL_1_1_1d",
    urls = ["https://github.com/openssl/openssl/archive/OpenSSL_1_1_1d.tar.gz"]
)
all_content = """filegroup(name = "all", srcs = glob(["**"]), visibility = ["//visibility:public"])"""

# openssl
http_archive(
    name = "openssl",
    build_file_content = all_content,
    strip_prefix = "openssl-OpenSSL_1_1_1d",
    urls = ["https://github.com/openssl/openssl/archive/OpenSSL_1_1_1d.tar.gz"]
)
# uv
http_archive(
    name = "libuv",
    build_file_content = all_content,
    strip_prefix = "libuv-1.42.0",
    urls = ["https://github.com/libuv/libuv/archive/refs/tags/v1.42.0.tar.gz"]

)

# See https://github.com/bazelbuild/rules_foreign_cc
load("@rules_foreign_cc//foreign_cc:defs.bzl", "configure_make")

config_setting(
    name = "darwin_build",
    values = {"cpu": "darwin"},
)

# See https://wiki.openssl.org/index.php/Compilation_and_Installation
# See https://github.com/bazelbuild/rules_foreign_cc/issues/338
#可以通过指定out_lib_dir选项指定编译出来的lib放在哪里，aka The path to where the compiled library binaries will be written to following a successful build
#对于使用configure-make形式的代码编译的方式，
configure_make(
    name = "openssl",
#实际上调用configure的命令，默认是调用configure，这里可以找到openssl里面调用的是config
    configure_command = "config",
#Any options to be put on the 'configure' command line.
    configure_options =
      select({
            ":darwin_build": [
              "shared",
              "ARFLAGS=r",
              "enable-ec_nistp_64_gcc_128",
              "no-ssl2", "no-ssl3", "no-comp"
            ],
            "//conditions:default": [
            ]}),
    #defines = ["NDEBUG"], Don't know how to use -D; NDEBUG seems to be the default anyway
#指定OPENSSL编译lib的源代码文件，aka Where the library source code is for openssl
    lib_source = "@openssl//:all",               
    visibility = ["//visibility:public"],
#Environment variables to be set for the 'configure' invocation.
    configure_env_vars =
        select({
            ":darwin_build": {
              "OSX_DEPLOYMENT_TARGET": "10.14",
              "AR": "",
            },
            "//conditions:default": {}}),
#用来指定共享出来的动态库、动态文件是什么，可以使用static_libraries属性来共享动态库
    out_shared_libs =
        select({
            ":darwin_build": [
                "libssl.dylib",
                "libcrypto.dylib",
            ],
            "//conditions:default": [
                "libssl.so",
                "libcrypto.so",
            ],
        })
)

# See https://github.com/bazelbuild/rules_foreign_cc
load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake")

cmake(
    name = "libuv",
    lib_source = "@libuv//:all",
    #out_static_libs = ["libuv.a"],
    out_static_libs = ["libuv_a.a"],
    #out_shared_libs = ["libuv.so.1.0.0"],  libuv.so是个链接，直接编译会报错
)

qcraft@BJ-vgdog:~/code_test/cmake2bazel$ bazelisk-linux-amd64 build //third_party/libuv:libuv
DEBUG: Rule 'libuv' indicated that a canonical reproducible form can be obtained by modifying arguments sha256 = "371e5419708f6aaeb8656671f89400b92a9bba6443369af1bb70bcd6e4b3c764"
DEBUG: Repository libuv instantiated at:
  /home/qcraft/code_test/cmake2bazel/WORKSPACE:36:13: in <toplevel>
Repository rule http_archive defined at:
  /home/qcraft/.cache/bazel/_bazel_qcraft/66cfb4dff202f299686aa7bc701960fa/external/bazel_tools/tools/build_defs/repo/http.bzl:336:31: in <toplevel>
INFO: Analyzed target //third_party/libuv:libuv (1 packages loaded, 1 target configured).
INFO: Found 1 target...
Target //third_party/libuv:libuv up-to-date:
  bazel-bin/third_party/libuv/libuv/include
  bazel-bin/third_party/libuv/libuv/lib/libuv_a.a
  bazel-bin/third_party/libuv/copy_libuv/libuv
INFO: Elapsed time: 31.269s, Critical Path: 30.97s
INFO: 2 processes: 1 internal, 1 linux-sandbox.
INFO: Build completed successfully, 2 total actions

py_library(
    name = "my_library",
    srcs = ["module1.py", "module2.py"],
    deps = ["//path/to:another_library"],
)

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

rules_python_version = "740825b7f74930c62f44af95c9a4c1bd428d2c53" # Latest @ 2021-06-23

http_archive(
    name = "rules_python",
    # Bazel will print the proper value to add here during the first build.
    # sha256 = "FIXME",
    strip_prefix = "rules_python-{}".format(rules_python_version),
    url = "https://github.com/bazelbuild/rules_python/archive/{}.zip".format(rules_python_version),
)

load("@rules_python//python:repositories.bzl", "python_register_toolchains")

python_register_toolchains(
    name = "python3_9",
    # Available versions are listed in @rules_python//python:versions.bzl.
    # We recommend using the same version your team is already standardized on.
    python_version = "3.9",
)

load("@python3_9//:defs.bzl", "interpreter")

load("@rules_python//python:pip.bzl", "pip_parse")

pip_parse(
    ...
    python_interpreter_target = interpreter,
    ...
)

load("@rules_python//python:pip.bzl", "pip_parse")

# Create a central repo that knows about the dependencies needed from
# requirements_lock.txt.
pip_parse(
   name = "my_deps",
   requirements_lock = "//path/to:requirements_lock.txt",
)
# Load the starlark macro which will define your dependencies.
load("@my_deps//:requirements.bzl", "install_deps")
# Call it to define repos for your requirements.
install_deps()

# requirements.txt for Python3 packages
jira

load("@my_deps//:requirements.bzl", "requirement")

py_library(
    name = "mylib",
    srcs = ["mylib.py"],
    deps = [
        ":myotherlib",
        requirement("some_pip_dep"),
        requirement("another_pip_dep"),
    ]
)

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

rules_python_version = "740825b7f74930c62f44af95c9a4c1bd428d2c53" # Latest @ 2021-06-23

http_archive(
    name = "rules_python",
    # Bazel will print the proper value to add here during the first build.
    # sha256 = "FIXME",
    strip_prefix = "rules_python-{}".format(rules_python_version),
    url = "https://github.com/bazelbuild/rules_python/archive/{}.zip".format(rules_python_version),
)

load("@my_deps//:requirements.bzl", "requirement")
load("@rules_python//python:defs.bzl", "py_binary")

py_binary(
    name = "validate_jira_issue",
    srcs = ["validate_jira_issue.py"],
    deps = [
        requirement("jira"),
    ],
)

#!/usr/bin/python3

import argparse
import logging
import os
import re
import sys
import traceback

import requests
from jira import JIRA, JIRAError

...

_JIRA_SERVER_ADDR = "https://daddy.jira.issues.net"
_JIRA_USER = "i am your daddy"


def jira_issue_link_check(jira_issue_text):

    try:
        jira_pass = "who is your daddy?"

        jira_server = JIRA(server=_JIRA_SERVER_ADDR, basic_auth=(_JIRA_USER, jira_pass))
    except Exception as e:
        logging.error(
            "Exception occurred when trying to connect to jira server, check connection?"
        )
        logging.error(traceback.format_exc())
        return False
    else:
        logging.info("Connection to jira & kms server success,  Congratulations")

    for issue in issues:
        logging.info(f"Get one jira issue: {issue}")
        try:
            jira_issue = jira_server.issue(issue.upper())
        except JIRAError as e:
            logging.error(
                f"Does the {issue} really exists? Exception {e.status_code}:{e.text} met "
            )
            return False
        else:
            logging.info(f"Find JIRA issue '{issue}'")

    return True
...

load("@rules_python//python:pip.bzl", "pip_parse")

# Create a central repo that knows about the dependencies needed from
# requirements_lock.txt.
pip_parse(
   name = "my_deps",
   requirements_lock = "//path/to:requirements_lock.txt",
)
# Load the starlark macro which will define your dependencies.
load("@my_deps//:requirements.bzl", "install_deps")
# Call it to define repos for your requirements.
install_deps()

# requirements.txt for Python3 packages
jira

# WORKSPACE

load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies", "go_register_toolchains")

go_rules_dependencies()

go_register_toolchains(version = "1.15.5")

# WORKSPACE

load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies", "go_register_toolchains")

go_rules_dependencies()

go_register_toolchains(version = "host")

bazel build -c opt --platforms=@io_bazel_rules_go//go/toolchain:linux_amd64 //save_money:money

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

# Download the Go rules.
http_archive(
    name = "io_bazel_rules_go",
    sha256 = "51dc53293afe317d2696d4d6433a4c33feedb7748a9e352072e2ec3c0dafd2c6",
    urls = [
        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.40.1/rules_go-v0.40.1.zip",
        "https://github.com/bazelbuild/rules_go/releases/download/v0.40.1/rules_go-v0.40.1.zip",
    ],
)

# Download Gazelle.
http_archive(
    name = "bazel_gazelle",
    sha256 = "727f3e4edd96ea20c29e8c2ca9e8d2af724d8c7778e7923a854b2c80952bc405",
    urls = [
        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.30.0/bazel-gazelle-v0.30.0.tar.gz",
        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.30.0/bazel-gazelle-v0.30.0.tar.gz",
    ],
)

# Load macros and repository rules.
load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies", "go_repository")

# Declare Go direct dependencies.
go_repository(
    name = "org_golang_x_net",
    importpath = "golang.org/x/net",
    sum = "h1:zK/HqS5bZxDptfPJNq8v7vJfXtkU7r9TLIoSr1bXaP4=",
    version = "v0.0.0-20200813134508-3edf25e44fcc",
)

# Declare indirect dependencies and register toolchains.
go_rules_dependencies()

go_register_toolchains(version = "1.20.5")

gazelle_dependencies()

bazel run //:gazelle update-repos repo-uri

bazel run //:gazelle update-repos github.com/segmentio/kafka-g

go_repository(
    name = "com_github_segmentio_kafka_go",
    importpath = "github.com/segmentio/kafka-go",
    sum = "h1:Mv9AcnCgU14/cU6Vd0wuRdG1FBO0HzXQLnjBduDLy70=",
    version = "v0.3.4",
)

load("@bazel_gazelle//:deps.bzl", "go_repository")

def grouped_go_dependencies():
    go_repository(
        name = "com_github_golang_glog",
        build_file_proto_mode = "disable_global",
        importpath = "github.com/golang/glog",
        sum = "h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ=",
        version = "v1.0.0",
    )

load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
load("//bazel:go_deps.bzl", "grouped_go_dependencies")

grouped_go_dependencies()

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

http_archive(
    name = "io_bazel_rules_go",
    sha256 = "51dc53293afe317d2696d4d6433a4c33feedb7748a9e352072e2ec3c0dafd2c6",
    urls = [
        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.40.1/rules_go-v0.40.1.zip",
        "https://github.com/bazelbuild/rules_go/releases/download/v0.40.1/rules_go-v0.40.1.zip",
    ],
)

load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")

go_rules_dependencies()

go_register_toolchains(version = "1.20.5")

load("@io_bazel_rules_go//go:def.bzl", "go_binary")

go_binary(
    name = "hello",
    srcs = ["hello.go"],
)

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

http_archive(
    name = "io_bazel_rules_go",
    sha256 = "51dc53293afe317d2696d4d6433a4c33feedb7748a9e352072e2ec3c0dafd2c6",
    urls = [
        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.40.1/rules_go-v0.40.1.zip",
        "https://github.com/bazelbuild/rules_go/releases/download/v0.40.1/rules_go-v0.40.1.zip",
    ],
)

http_archive(
    name = "bazel_gazelle",
    sha256 = "727f3e4edd96ea20c29e8c2ca9e8d2af724d8c7778e7923a854b2c80952bc405",
    urls = [
        "https://mirror.bazel.build/github.com/bazelbuild/bazel-gazelle/releases/download/v0.30.0/bazel-gazelle-v0.30.0.tar.gz",
        "https://github.com/bazelbuild/bazel-gazelle/releases/download/v0.30.0/bazel-gazelle-v0.30.0.tar.gz",
    ],
)

load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")

go_rules_dependencies()

go_register_toolchains(version = "1.20.5")

gazelle_dependencies()

load("@bazel_gazelle//:def.bzl", "gazelle")

# gazelle:prefix github.com/example/project
gazelle(name = "gazelle")

bazel run //:gazelle

package(default_visibility = ["//visibility:public"])

sh_library(
    name = "sh_flags",
    data = ["shflags"],
)

sh_test(
    name = "run_compare",
    size = "medium",
    srcs = ["run_compare.sh"],
    data = [
        "//save_money/compare:jandan",
    ],
    tags = ["manual"],
    # Notes: deps should only be sh_library,
    # other depends such as cc_binary and data should include in data field
    deps = [
        ":sh_flags",
    ],
)

TOP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
source "${TOP_DIR}/shflags"

DEFINE_boolean 'chinese' "${FLAGS_FALSE}" 'If true, use save chinese yuan.'
DEFINE_boolean 'US' "${FLAGS_TRUE}" 'If true, save us dollar.'

# Parse the command-line.
FLAGS "$@" || exit 1
eval set -- "${FLAGS_ARGV}"

set -e

echo "Envoking save money mode"
save_money/compare/jandan ${FLAGS_chinese} ${FLAGS_US}

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive(
    name = "foo",
    urls = ["https://example.com/foo.zip"],
    sha256 = "c9526390a7cd420fdcec2988b4f3626fe9c5b51e2959f685e8f4d170d1a9bd96",
)

version = "1.xx.x"
http_archive(
    name = "com_github_grpc_grpc",
    strip_prefix = "grpc-{}".format(version),
    sha256 = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    urls = [
        "https://xxxxxxxxxxxxxxxxx/grpc-{}.tar.gz".format(version),
        "https://xxxxxxxxxxxxxxxxxxx{}.tar.gz".format(version),
    ],
    patch_args = ["-p1"],
    patches = [
        clean_dep("//third_party/grpc:p01xxxxxxxxxxxxx.patch"),
        clean_dep("//third_party/grpc:p02xxxxxxxxxxxxx.patch"),
        clean_dep("//third_party/grpc:p03xxxxxxxxxxxxx.patch"),
    ],
)

cc_binary(
    name = "grpc_test_main",
    testonly = True,
    srcs = [
        "grpc_test_main.cc",
    ],
    deps = [
        "//xxxxx/proto:grpc_test_main",
        "@com_github_google_glog//:glog",
        "@com_github_grpc_grpc//:grpc++",
    ],
)

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

http_archive(
    name = "com_github_google_glog",
    sha256 = "eede71f28371bf39aa69b45de23b329d37214016e2055269b3b5e7cfd40b59f5",
    strip_prefix = "glog-0.5.0",
    urls = ["https://github.com/google/glog/archive/refs/tags/v0.5.0.tar.gz"],
)

# We have to define gflags as well because it's a dependency of glog.
http_archive(
    name = "com_github_gflags_gflags",
    sha256 = "34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf",
    strip_prefix = "gflags-2.2.2",
    urls = ["https://github.com/gflags/gflags/archive/refs/tags/v2.2.2.tar.gz"],
)

# 1. The metadata of glog is fetched from the BCR, including its dependencies (gflags).
# 2. The `repo_name` attribute allows users to reference this dependency via the `com_github_google_glog` repo name.
bazel_dep(name = "glog", version = "0.5.0", repo_name = "com_github_google_glog")

build --enable_bzlmod

       A 1.0
      /     \
   B 1.0    C 1.1
     |        |
   D 1.0    D 1.1

try-import %workspace%/user.bazelrc

glob(["**/**"])

# myapp/BUILD

cc_binary(
    name = "mybinary",
    srcs = ["main.cc"],
    deps = select({
        ":arm_build": [":arm_lib"],
        ":x86_debug_build": [":x86_dev_lib"],
        "//conditions:default": [":generic_lib"],
    }),
)

config_setting(
    name = "arm_build",
    values = {"cpu": "arm"},
)

config_setting(
    name = "x86_debug_build",
    values = {
        "cpu": "x86",
        "compilation_mode": "dbg",
    },
)

sh_binary(
    name = "my_target",
    srcs = ["always_include.sh"] +
           select({
               ":armeabi_mode": ["armeabi_src.sh"],
               ":x86_mode": ["x86_src.sh"],
           }) +
           select({
               ":opt_mode": ["opt_extras.sh"],
               ":dbg_mode": ["dbg_extras.sh"],
           }),
)

# myapp/BUILD

sh_binary(
    name = "my_rocks",
    srcs = select({
        ":basalt": ["pyroxene.sh"],
        ":marble": ["calcite.sh"],
        "//conditions:default": ["feldspar.sh"],
    }),
)

config_setting(
    name = "basalt",
    constraint_values = [
        ":black",
        ":igneous",
    ],
)

config_setting(
    name = "marble",
    constraint_values = [
        ":white",
        ":metamorphic",
    ],
)

# constraint_setting acts as an enum type, and constraint_value as an enum value.
constraint_setting(name = "color")
constraint_value(name = "black", constraint_setting = "color")
constraint_value(name = "white", constraint_setting = "color")
constraint_setting(name = "texture")
constraint_value(name = "smooth", constraint_setting = "texture")
constraint_setting(name = "type")
constraint_value(name = "igneous", constraint_setting = "type")
constraint_value(name = "metamorphic", constraint_setting = "type")

platform(
    name = "basalt_platform",
    constraint_values = [
        ":black",
        ":igneous",
    ],
)

platform(
    name = "marble_platform",
    constraint_values = [
        ":white",
        ":smooth",
        ":metamorphic",
    ],
)

bazel build //my_app:my_rocks --platforms=//myapp:marble_platform

bazel build //my_app:my_rocks --define color=white --define texture=smooth --define type=metamorphic

$ bazel build --platforms=//:myplatform //...

$ bazel build --platforms=//:myplatform //:all

$ bazel build --platforms=//:myplatform //:target_incompatible_with_myplatform
...
ERROR: Target //:target_incompatible_with_myplatform is incompatible and cannot be built, but was explicitly requested.
...
FAILED: Build did NOT complete successfully

# //:WORKSPACE
load(
    "@bazel_tools//tools/build_defs/repo:git.bzl",
    "git_repository",
)

git_repository(
       name = "bazel_clang_tidy",
       commit = "69aa13e6d7cf102df70921c66be15d4592251e56",
       remote = "https://github.com/erenon/bazel_clang_tidy.git",
)

bazel build //... \
  --aspects @bazel_clang_tidy//clang_tidy:clang_tidy.bzl%clang_tidy_aspect \
  --output_groups=report

```ini
build:tidy --aspects //bazel/clang_tidy:clang_tidy.bzl%clang_tidy_aspect
build:tidy --build_tag_filters=-no-tidy
build:tidy --output_groups=report

```

bazel build --config=tidy //...

# //:BUILD
filegroup(
       name = "clang_tidy_config",
       srcs = [".clang-tidy"],
       visibility = ["//visibility:public"],
)

bazel build //... \
  --aspects @bazel_clang_tidy//clang_tidy:clang_tidy.bzl%clang_tidy_aspect \
  --output_groups=report \
  --@bazel_clang_tidy//:clang_tidy_config=//:clang_tidy_config

http_archive(
    name = "com_grail_bazel_compdb",
    strip_prefix = "bazel-compilation-database-0.5.2",
    urls = ["https://github.com/grailbio/bazel-compilation-database/archive/0.5.2.tar.gz"],
)

load("@com_grail_bazel_compdb//:deps.bzl", "bazel_compdb_deps")
bazel_compdb_deps()

## Replace workspace_name and dir_path as per your setup.
load("@com_grail_bazel_compdb//:defs.bzl", "compilation_database")
load("@com_grail_bazel_output_base_util//:defs.bzl", "OUTPUT_BASE")

compilation_database(
    name = "example_compdb",
    targets = [
        "//a_cc_binary_label",
        "//a_cc_library_label",
    ],
    # OUTPUT_BASE is a dynamic value that will vary for each user workspace.
    # If you would like your build outputs to be the same across users, then
    # skip supplying this value, and substitute the default constant value
    # "__OUTPUT_BASE__" through an external tool like `sed` or `jq` (see
    # below shell commands for usage).
    output_base = OUTPUT_BASE,
)

# Command to generate the compilation database file.
bazel build //path/to/pkg/dir:example_compdb

# Location of the compilation database file.
outfile="$(bazel info bazel-bin)/path/to/pkg/dir/compile_commands.json"

# [Optional] Command to replace the marker for output_base in the file if you
# did not use the dynamic value in the example above.
output_base=$(bazel info output_base)
sed -i.bak "s@__OUTPUT_BASE__@${output_base}@" "${outfile}"

# The compilation database is now ready to use at this location.
echo "Compilation Database: ${outfile}"

INSTALL_DIR="/usr/local/bin"
VERSION="0.5.2"

# Download and symlink.
(
  cd "${INSTALL_DIR}" \
  && curl -L "https://github.com/grailbio/bazel-compilation-database/archive/${VERSION}.tar.gz" | tar -xz \
  && ln -f -s "${INSTALL_DIR}/bazel-compilation-database-${VERSION}/generate.py" bazel-compdb
)

bazel-compdb # This will generate compile_commands.json in your workspace root.

# To pass additional flags to bazel, pass the flags as arguments after --
bazel-compdb -- [additional flags for bazel]

# You can tweak some behavior with flags:
# 1. To use the source dir instead of bazel-execroot for directory in which clang commands are run.
bazel-compdb -s
bazel-compdb -s -- [additional flags for bazel]
# 2. To consider only targets given by a specific query pattern, say `//cc/...`. Also see below section for another way.
bazel-compdb -q //cc/...
bazel-compdb -q //cc/... -- [additional flags for bazel]

```python

load("@io_bazel_rules_docker//cc:image.bzl", "cc_image")
load("@io_bazel_rules_docker//container:container.bzl", "container_bundle", "container_import")

package(default_visibility = ["//visibility:public"])

filegroup(
    name = "base_image_config_json",
    srcs = [
        "base_image_config.json",
    ],
    visibility = ["//visibility:public"],
)

container_import(
    name = "base_image",
    base_image_digest = "sha256:xxxxxxxxxxxxxxxxxxxxxx2e457cd116a429257d8f3615e51a55c56b3705539568d58c",
    base_image_registry = "registry.xxxxxx.com",
    base_image_repository = "global/xxxxxx",
    config = ":base_image_config_json",
    layers = [],
    tags = [
        "no-cache",
        "no-remote",
    ],
)
```

```python

load("@io_bazel_rules_docker//cc:image.bzl", "cc_image")
load("@io_bazel_rules_docker//container:container.bzl", "container_bundle", "container_import")

package(default_visibility = ["//visibility:public"])


cc_image(
    name = "image",
    base = ":base_image",
    binary = "//offboard/xxx:abc_target",
    tags = [
        "no-remote",
    ],
)

container_bundle(
    name = "taged_image",
    images = {
        "$(REAL_IMAGE)": ":image",
    },
    tags = [
        "no-remote",
    ],
)
```

```shellscript
bazel run --define REAL_IMAGE=hxndg:image xxxx/xxx/xxx:taged_image -- --norun

```

[example@example-dev-example:/example(master) ] $ bazel aquery //expxxx/xxx/xxxxx_
INFO: Invocation ID: ea675cf9-4014-42b4-ac53-dc134710a7ea
INFO: Analyzed target //experimental/xxx/xxx/xxxxx_ (1 packages loaded, 2 targets configured).
INFO: Found 1 target...
BazelCppSemantics_build_arch_k8-fastbuild for //experimental/xxxxxxs/xxx/xxxx:xxxxx
  Mnemonic: Middleman
  Target: //experimental/xxxxxxs/xxx/xxx/xxxxx_
  Configuration: k8-fastbuild
  Execution platform: @local_config_platform//:host
  ActionKey: 709e80c88487a2411e1ee4dfb9f22a861492d20c4765150c0c794abd70f8147c
  Inputs: [bazel-out/k8-fastbuild/internal/_middlemen/@com_Ugoogle_Ugoogletest_S_S_Cgtest-BazelCppSemantics_build_arch_k8-fastbuild, bazel-out/k8-fastbuild/internal/_middlemen/@com_Ugoogle_Ugoogletest_S_S_Cgtest_Umain-BazelCppSemantics_build_arch_k8-fastbuild]
  Outputs: [bazel-out/k8-fastbuild/internal/_middlemen/_S_Sexperimental_Sxxxx_Sxxxx_Ssimd_Cxxxx_Uxxxx-BazelCppSemantics_build_arch_k8-fastbuild]

action 'Compiling experimental/xxxxxxs/xxx/xxx/xxxxx.cc'
  Mnemonic: CppCompile
  Target: //experimental/xxxxxxs//xxx/xxx/xxxxx_test
  Configuration: k8-fastbuild
  Execution platform: @local_config_platform//:host
  ActionKey: bc54c74489c4827e0560d03bea1096265f8c92eb0d9ac316eacc55031d0cd65f
  Inputs: [bazel-out/k8-fastbuild/internal/_middlemen/_S_Sexperimental_Sxxxx_Sxxxx_Ssimd_Cxxxx_Uxxxx-BazelCppSemantics_build_arch_k8-fastbuild, xxxxx/xxx/xxxx/xxxx/fma_test.cc, external/bazel_tools/tools/cpp/grep-includes.sh, external/llvm_repo/llvm/bin/clang, external/llvm_repo/llvm/bin/clang++, external/llvm_repo/llvm/bin/clang-cpp, external/llvm_repo/llvm/include/c++/v1/__algorithm/adjacent_find.h, external/llvm_repo/llvm/include/c++/v1/__algorithm/all_of.h, 
  ...
external/local_cuda/cuda/nvvm/libnvvm-samples/simple/simple-gpu64.ll, external/local_cuda/cuda/nvvm/libnvvm-samples/simple/simple.c]
  Outputs: [bazel-out/k8-fastbuild/bin/xxxxx/xxx/xxxx/xxxx/_objs/fma_test/fma_test.pic.d, bazel-out/k8-fastbuild/bin/xxxxx/xxx/xxxx/xxxx/_objs/fma_test/fma_test.pic.o]
  Environment: [DOCKER_REPO_CACHE=/example_cache/docker, GOCACHE=/example_cache/go/cache, GOMODCACHE=/example_cache/go/module, GO_REPOSITORY_USE_HOST_CACHE=1, OMP_NUM_THREADS=1, PATH=/bin:/usr/bin:/usr/local/bin]
  Command Line: (exec external/llvm_toolchain/bin/cc_wrapper.sh \
    '--target=x86_64-unknown-linux-gnu' \
    -U_FORTIFY_SOURCE \
    -fstack-protector \
    -fno-omit-frame-pointer \
    -fcolor-diagnostics \
    -Wall \
    -Wthread-safety \
    -Wself-assign \
    -mavx2 \
    -mfma \
    '-std=c++17' \
    '-stdlib=libstdc++' \
    -MD \
    -MF \
    bazel-out/k8-fastbuild/bin/xxxxx/xxx/xxxx/xxxx/_objs/fma_test/fma_test.pic.d \
    '-frandom-seed=bazel-out/k8-fastbuild/bin/xxxxx/xxx/xxxx/xxxx/_objs/fma_test/fma_test.pic.o' \
    -fPIC \
    -iquote. \
    -iquotebazel-out/k8-fastbuild/bin \
    -iquoteexternal/com_google_googletest \
    -iquotebazel-out/k8-fastbuild/bin/external/com_google_googletest \
    -iquoteexternal/bazel_tools \
    -iquotebazel-out/k8-fastbuild/bin/external/bazel_tools \
    -isystem \
    external/com_google_googletest/googlemock \
    -isystem \
    bazel-out/k8-fastbuild/bin/external/com_google_googletest/googlemock \
    -isystem \
    external/com_google_googletest/googlemock/include \
    -isystem \
    bazel-out/k8-fastbuild/bin/external/com_google_googletest/googlemock/include \
    -isystem \
    external/com_google_googletest/googletest \
    -isystem \
    bazel-out/k8-fastbuild/bin/external/com_google_googletest/googletest \
    -isystem \
    external/com_google_googletest/googletest/include \
    -isystem \
    bazel-out/k8-fastbuild/bin/external/com_google_googletest/googletest/include \
    -UQ_CPU_ONLY \
    -DS2_USE_GFLAGS \
    -DS2_USE_GLOG \
    -DDCHECK_ALWAYS_ON \
    '-std=c++17' \
    -Wdeprecated-declarations \
    '-Werror=reorder' \
    -Wno-unknown-warning-option \
    -Wno-unused-local-typedef \
    -Wdelete-non-abstract-non-virtual-dtor \
    -Wenum-compare \
    -Wextra-tokens \
    -Wignored-qualifiers \
    -Winconsistent-missing-override \
    -Wlogical-op-parentheses \
    -Wmacro-redefined \
    -Wpessimizing-move \
    -Wrange-loop-construct \
    -Wreturn-stack-address \
    -Wreturn-type \
    -Wself-assign-overloaded \
    -Wswitch \
    -Wthread-safety-analysis \
    -Wunused-but-set-variable \
    -Wunused-function \
    -Wunused-lambda-capture \
    -Wunused-parameter \
    -Wunused-private-field \
    -Wunused-result \
    -Wunused-variable \
    '-ffp-contract=off' \
    -Wno-deprecated-builtins \
    -Wno-deprecated-declarations \
    -Wextra \
    -Wno-sign-compare \
    -Werror \
    '-Wno-error=unused-parameter' \
    '-Wno-error=unused-but-set-variable' \
    -fno-access-control \
    -no-canonical-prefixes \
    -Wno-builtin-macro-redefined \
    '-D__DATE__="redacted"' \
    '-D__TIMESTAMP__="redacted"' \
    '-D__TIME__="redacted"' \
    '-fdebug-prefix-map=external/llvm_repo/llvm/=__bazel_toolchain_llvm_repo__/' \
    -c \
    xxxxx/xxx/xxxx/xxxx/fma_test.cc \
    -o \
    bazel-out/k8-fastbuild/bin/xxxxx/xxx/xxxx/xxxx/_objs/fma_test/fma_test.pic.o)
# Configuration: 8b90087b699d1ce6fd2f950930f3d839cf137c3e40ca61e38ebd7a75ed2a64eb
# Execution platform: @local_config_platform//:host

$(bazel info output_base)/command.profile.gz

backplane:
  redisUri: "redis://xxxxxxxxxxxxxxxxxxxxxxxx:6379"
  queues:
    - name: "gpu"
      allowUnmatched: false
      properties:
        - name: "gpu"
          value: "1"
    - name: "cpu"
      allowUnmatched: true
      properties:
        - name: "min-cores"
          value: "*"
        - name: "max-cores"
          value: "*"
digestFunction: SHA256
maxEntrySizeBytes: 123456
server:
  name: "shard"
  recordBesEvents: true

backplane:
  redisUri: "redis://xxxxxxxxxxxxxxxxxxxxxxxx:6379"
  queues:
    - name: "cpu"
      allowUnmatched: true
      properties:
        - name: "min-cores"
          value: "*"
        - name: "max-cores"
          value: "*"
digestFunction: SHA256
maxEntrySizeBytes: 123456     
worker:
  port: 8982
  publicName: "localhost:8982"
  executeStageWidth: 80
  inputFetchStageWidth: 8
  realInputDirectories:
    - "external"
  storages:
    - type: FILESYSTEM
      maxSizeBytes: 123124124124123123

backplane:
  redisUri: "redis://xxxxxxxxxxxxxxxxxxxxxxxx:6379"
  queues:
    - name: "gpu"
      allowUnmatched: false
      properties:
        - name: "gpu"
          value: "1"
digestFunction: SHA256
maxEntrySizeBytes: 12345678      
worker:
  port: 8982
  publicName: "localhost:8982"
  executeStageWidth: 8
  inputFetchStageWidth: 8
  realInputDirectories:
    - "external"
  storages:
    - type: FILESYSTEM
      maxSizeBytes: 123123123123123
  dequeueMatchSettings:
    acceptEverything: true
    allowUnmatched: false
    properties:
      - name: "gpu"
        value: "1"

```python
    exec_properties = {"gpu": "1"},
```

```shellscript
build --remote_executor=服务地址
build --remote_cache=
build --remote_timeout=5m"
build --jobs=30 #控制并发数量
```

```yaml
        livenessProbe:
          exec:
            command:
            - /bin/bash
            - -c
            - |-
              java_thread_count=$(ps huH p $(ps -C java -o pid=) | grep java | wc -l);
              if [ "$java_thread_count" -gt "1000" ]; then
                exit 1
              fi
          failureThreshold: 12
          initialDelaySeconds: 300
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 3
```

# Dockerhub example:
$ docker pull buchgr/bazel-remote-cache
$ docker run -u 1000:1000 -v /path/to/cache/dir:/data \
	-p 9090:8080 -p 9092:9092 buchgr/bazel-remote-cache \
	--max_size 5

common --remote_cache=xxx地址

bazel --host_jvm_args=-Xmx4g build -c opt

bazel --host_jvm_args=-Xmx4g build -c opt xxxxxx --notrack_incremental_state --nokeep_state_after_build --discard_analysis_cache