replaced baidu::rpc:: with brpc::

docs/cn/bvar_c++.md

@@ -163,7 +163,7 @@ class Variable {
 $ cat bvar.echo_server.data                 
 rpc_server_8002_builtin_service_count : 20
 rpc_server_8002_connection_count : 1
-rpc_server_8002_nshead_service_adaptor : baidu::rpc::policy::NovaServiceAdaptor
+rpc_server_8002_nshead_service_adaptor : brpc::policy::NovaServiceAdaptor
 rpc_server_8002_service_count : 1
 rpc_server_8002_start_time : 2015/07/24-21:08:03
 rpc_server_8002_uptime_ms : 14740954

docs/cn/client.md

-Client指发起请求的一端，在baidu-rpc中没有对应的实体，取而代之的是[baidu::rpc::Channel](http://websvn.work.baidu.com/repos/public/show/trunk/baidu-rpc/src/baidu/rpc/channel.h?revision=HEAD)，它代表和一台或一组服务器的交互通道，Client和Channel在角色上的差别在实践中并不重要，你可以把Channel视作Client。
+Client指发起请求的一端，在baidu-rpc中没有对应的实体，取而代之的是[brpc::Channel](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/channel.h)，它代表和一台或一组服务器的交互通道，Client和Channel在角色上的差别在实践中并不重要，你可以把Channel视作Client。
 
 Channel可以被进程中的所有线程共用，你不需要为每个线程创建独立的Channel，也不需要用锁互斥。不过Channel的创建和析构并不是线程安全的，请确保在Init成功后再被多线程访问，在没有线程访问后再析构。
 
@@ -10,7 +10,7 @@ Channel可以被进程中的所有线程共用，你不需要为每个线程创
 
 就像大部分类那样，Channel必须在**Init**之后才能使用，options为NULL时所有参数取默认值，如果你要使用非默认值，这么做就行了：
 ```
-baidu::rpc::ChannelOptions options;  // 包含了默认值
+brpc::ChannelOptions options;  // 包含了默认值
 options.xxx = yyy;
 ...
 channel.Init(..., &options);
@@ -61,7 +61,7 @@ r31806之后当load_balancer_name为NULL或空时，此Init转为连接单台ser
 
 ### bns://<bns-name>
 
-BNS是百度内常用的名字服务，比如bns://rdev.matrix.all，其中"bns"是protocol，"rdev.matrix.all"是service-name。相关一个gflag是[-ns_access_interval](http://brpc.baidu.com:8765/flags/ns_access_interval)。
+BNS是百度内常用的名字服务，比如bns://rdev.matrix.all，其中"bns"是protocol，"rdev.matrix.all"是service-name。相关一个gflag是-ns_access_interval: ![img](../images/ns_access_interval.png)
 
 如果bns中显示不为空，但Channel却说找不到服务器，那么有可能bns列表中的机器状态位（status）为非0，含义为机器不可用，所以不会被加入到server候选集中，具体可通过命令行查看：
 
@@ -83,7 +83,7 @@ BNS是百度内常用的名字服务，比如bns://rdev.matrix.all，其中"bns"
 
 当名字服务获得机器列表后，可以自定义一个过滤器进行筛选，最后把结果传递给负载均衡：
 
-![img](http://wiki.baidu.com/download/attachments/71337222/dafe68fd-6ace-444a-8df9-72bf0311298d.JPG?version=1&modificationDate=1463536052000&api=v2)
+![img](../images/ns_filter.jpg)
 
 过滤器的接口如下：
 ```
@@ -103,9 +103,9 @@ struct ServerNode {
 ```
 常见的业务策略如根据bns中每个server不同tag进行过滤，自定义的过滤器配置在ChannelOptions中，默认为NULL（不过滤）：
 ```
-class MyNamingServiceFilter : public baidu::rpc::NamingServiceFilter {
+class MyNamingServiceFilter : public brpc::NamingServiceFilter {
 public:
-    bool Accept(const baidu::rpc::ServerNode& server) const {
+    bool Accept(const brpc::ServerNode& server) const {
         return server.tag == "main";
     }
 };
@@ -114,7 +114,7 @@ int main() {
     ...
     MyNamingServiceFilter my_filter;
     ...
-    baidu::rpc::ChannelOptions options;
+    brpc::ChannelOptions options;
     options.ns_filter = &my_filter;
     ...
 }
@@ -146,7 +146,7 @@ locality-aware，优先选择延时低的下游，直到其延时高于其他机
 
 发起RPC前需要设置Controller.set_request_code()，否则RPC会失败。request_code一般是请求中主键部分的32位哈希值，**不需要和负载均衡使用的哈希算法一致**。比如用c_murmurhash算法也可以用md5计算哈希值。
 
-[baidu/rpc/policy/hasher.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/policy/hasher.h)中包含了常用的hash函数。如果用std::string key代表请求的主键，controller.set_request_code(baidu::rpc::policy::MurmurHash32(key.data(), key.size()))就正确地设置了request_code。
+[baidu/rpc/policy/hasher.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/policy/hasher.h)中包含了常用的hash函数。如果用std::string key代表请求的主键，controller.set_request_code(brpc::policy::MurmurHash32(key.data(), key.size()))就正确地设置了request_code。
 
 注意甄别请求中的“主键”部分和“属性”部分，不要为了偷懒或通用，就把请求的所有内容一股脑儿计算出哈希值，属性的变化会使请求的目的地发生剧烈的变化。另外也要注意padding问题，比如struct Foo { int32_t a; int64_t b; }在64位机器上a和b之间有4个字节的空隙，内容未定义，如果像hash(&foo, sizeof(foo))这样计算哈希值，结果就是未定义的，得把内容紧密排列或序列化后再算。
 
@@ -177,7 +177,7 @@ XXX_Stub(&channel).some_method(controller, request, response, done);
 ```
 MyRequest request;
 MyResponse response;
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 XXX_Stub stub(&channel);
  
 request.set_foo(...);
@@ -203,10 +203,10 @@ if (cntl->Failed()) {
 
 ### 使用NewCallback
 ```
-static void OnRPCDone(MyResponse* response, baidu::rpc::Controller* cntl) {
+static void OnRPCDone(MyResponse* response, brpc::Controller* cntl) {
     // unique_ptr会帮助我们在return时自动删掉response/cntl，防止忘记。gcc 3.4下的unique_ptr是public/common提供的模拟版本。
     std::unique_ptr<MyResponse> response_guard(response);
-    std::unique_ptr<baidu::rpc::Controller> cntl_guard(cntl);
+    std::unique_ptr<brpc::Controller> cntl_guard(cntl);
     if (cntl->Failed()) {
         // RPC出错了. response里的值是未定义的，勿用。
     } else {
@@ -216,7 +216,7 @@ static void OnRPCDone(MyResponse* response, baidu::rpc::Controller* cntl) {
 }
  
 MyResponse* response = new MyResponse;
-baidu::rpc::Controller* cntl = new baidu::rpc::Controller;
+brpc::Controller* cntl = new brpc::Controller;
 MyService_Stub stub(&channel);
  
 MyRequest request;  // you don't have to new request, even in an asynchronous call.
@@ -224,7 +224,7 @@ request.set_foo(...);
 cntl->set_timeout_ms(...);
 stub.some_method(cntl, &request, response, google::protobuf::NewCallback(OnRPCDone, response, cntl));
 ```
-由于protobuf 3把NewCallback设置为私有，r32035后baidu-rpc把NewCallback独立于[src/baidu/rpc/callback.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/callback.h)。如果你的程序出现NewCallback相关的编译错误，把google::protobuf::NewCallback替换为baidu::rpc::NewCallback就行了。
+由于protobuf 3把NewCallback设置为私有，r32035后baidu-rpc把NewCallback独立于[src/baidu/rpc/callback.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/callback.h)。如果你的程序出现NewCallback相关的编译错误，把google::protobuf::NewCallback替换为brpc::NewCallback就行了。
 
 ### 继承google::protobuf::Closure
 
@@ -244,7 +244,7 @@ public:
     }
  
     MyResponse response;
-    baidu::rpc::Controller cntl;
+    brpc::Controller cntl;
 }
  
 OnRPCDone* done = new OnRPCDone;
@@ -269,14 +269,14 @@ stub.some_method(&done->cntl, &request, &done->response, done);
 
 如下代码发起两个异步RPC后等待它们完成。
 ```
-const baidu::rpc::CallId cid1 = controller1->call_id();
-const baidu::rpc::CallId cid2 = controller2->call_id();
+const brpc::CallId cid1 = controller1->call_id();
+const brpc::CallId cid2 = controller2->call_id();
 ...
 stub.method1(controller1, request1, response1, done1);
 stub.method2(controller2, request2, response2, done2);
 ...
-baidu::rpc::Join(cid1);
-baidu::rpc::Join(cid2);
+brpc::Join(cid1);
+brpc::Join(cid2);
 ```
 **在发起RPC前**调用Controller.call_id()获得一个id，发起RPC调用后Join那个id。
 
@@ -306,36 +306,36 @@ MyResponse* response2 = new MyResponse;
 stub.method1(controller1, &request1, response1, google::protobuf::NewCallback(on_rpc_done, controller1, response1));
 stub.method2(controller2, &request2, response2, google::protobuf::NewCallback(on_rpc_done, controller2, response2));
 ...
-baidu::rpc::Join(controller1->call_id());   // 错误，controller1可能被on_rpc_done删除了
-baidu::rpc::Join(controller2->call_id());   // 错误，controller2可能被on_rpc_done删除了
+brpc::Join(controller1->call_id());   // 错误，controller1可能被on_rpc_done删除了
+brpc::Join(controller2->call_id());   // 错误，controller2可能被on_rpc_done删除了
 ```
 
 ## 半同步
 
 Join可用来实现“半同步”操作：即等待多个异步操作返回。由于调用处的代码会等到多个RPC都结束后再醒来，所以controller和response都可以放栈上。
 ```
-baidu::rpc::Controller cntl1;
-baidu::rpc::Controller cntl2;
+brpc::Controller cntl1;
+brpc::Controller cntl2;
 MyResponse response1;
 MyResponse response2;
 ...
-stub1.method1(&cntl1, &request1, &response1, baidu::rpc::DoNothing());
-stub2.method2(&cntl2, &request2, &response2, baidu::rpc::DoNothing());
+stub1.method1(&cntl1, &request1, &response1, brpc::DoNothing());
+stub2.method2(&cntl2, &request2, &response2, brpc::DoNothing());
 ...
-baidu::rpc::Join(cntl1.call_id());
-baidu::rpc::Join(cntl2.call_id());
+brpc::Join(cntl1.call_id());
+brpc::Join(cntl2.call_id());
 ```
-baidu::rpc::DoNothing()可获得一个什么都不干的done，专门用于半同步访问。它的生命周期由框架管理，用户不用关心。
+brpc::DoNothing()可获得一个什么都不干的done，专门用于半同步访问。它的生命周期由框架管理，用户不用关心。
 
 注意在上面的代码中，我们在RPC结束后又访问了controller.call_id()，这是没有问题的，因为DoNothing中并不会像上面的on_rpc_done中那样删除Controller。
 
 ## 取消RPC
 
-baidu::rpc::StartCancel(CallId)可取消任意RPC，CallId必须**在发起RPC前**通过Controller.call_id()获得，其他时刻都可能有race condition。
+brpc::StartCancel(CallId)可取消任意RPC，CallId必须**在发起RPC前**通过Controller.call_id()获得，其他时刻都可能有race condition。
 
 Icon
 
-是baidu::rpc::StartCancel(CallId)，不是controller.StartCancel()，后者被禁用，没有效果。
+是brpc::StartCancel(CallId)，不是controller.StartCancel()，后者被禁用，没有效果。
 
 顾名思义，StartCancel调用完成后RPC并未立刻结束，你不应该碰触Controller的任何字段或删除任何资源，它们自然会在RPC结束时被done中对应逻辑处理。如果你一定要在原地等到RPC结束（一般不需要），则可通过Join(call_id)。
 
@@ -364,7 +364,7 @@ r31384后通过local_side()方法可**在RPC结束后**获得发起RPC的地址
 LOG(INFO) << "local_side=" << cntl->local_side(); 
 printf("local_side=%s\n", base::endpoint2str(cntl->local_side()).c_str());
 ```
-## 新建baidu::rpc::Controller的代价大吗
+## 新建brpc::Controller的代价大吗
 
 不大，不用刻意地重用，但Controller是个大杂烩，可能会包含一些缓存，Reset()可以避免反复地创建这些缓存。
 
@@ -372,13 +372,13 @@ printf("local_side=%s\n", base::endpoint2str(cntl->local_side()).c_str());
 ```
 // snippet1
 for (int i = 0; i < n; ++i) {
-    baidu::rpc::Controller controller;
+    brpc::Controller controller;
     ...
     stub.CallSomething(..., &controller);
 }
  
 // snippet2
-baidu::rpc::Controller controller;
+brpc::Controller controller;
 for (int i = 0; i < n; ++i) {
     controller.Reset();
     ...
@@ -391,8 +391,8 @@ for (int i = 0; i < n; ++i) {
 
 Client端的设置主要由三部分组成：
 
-- baidu::rpc::ChannelOptions: 定义在[src/baidu/rpc/channel.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/channel.h)中，用于初始化Channel，一旦初始化成功无法修改。
-- baidu::rpc::Controller: 定义在[src/baidu/rpc/controller.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/controller.h)中，用于在某次RPC中覆盖ChannelOptions中的选项，可根据上下文每次均不同。
+- brpc::ChannelOptions: 定义在[src/baidu/rpc/channel.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/channel.h)中，用于初始化Channel，一旦初始化成功无法修改。
+- brpc::Controller: 定义在[src/baidu/rpc/controller.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/controller.h)中，用于在某次RPC中覆盖ChannelOptions中的选项，可根据上下文每次均不同。
 - 全局gflags：常用于调节一些底层代码的行为，一般不用修改。请自行阅读服务/flags页面中的说明。
 
 Controller包含了request中没有的数据和选项。server端和client端的Controller结构体是一样的，但使用的字段可能是不同的，你需要仔细阅读Controller中的注释，明确哪些字段可以在server端使用，哪些可以在client端使用。
@@ -449,28 +449,28 @@ Controller.set_max_retry()或ChannelOptions.max_retry设置最大重试次数，
 
 一些错误重试是没有意义的，就不会重试，比如请求有错时(EREQUEST)不会重试，因为server总不会接受。
 
-r32009后用户可以通过继承[baidu::rpc::RetryPolicy](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/retry_policy.h)自定义重试条件。r34642后通过cntl->response()可获得对应RPC的response。对ERPCTIMEDOUT代表的RPC超时总是不重试，即使RetryPolicy中允许。
+r32009后用户可以通过继承[brpc::RetryPolicy](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/retry_policy.h)自定义重试条件。r34642后通过cntl->response()可获得对应RPC的response。对ERPCTIMEDOUT代表的RPC超时总是不重试，即使RetryPolicy中允许。
 
 比如baidu-rpc默认不重试HTTP相关的错误，而你的程序中希望在碰到HTTP_STATUS_FORBIDDEN (403)时重试，可以这么做：
 ```
-#include <baidu/rpc/retry_policy.h>
+#include brpc/retry_policy.h>
  
-class MyRetryPolicy : public baidu::rpc::RetryPolicy {
+class MyRetryPolicy : public brpc::RetryPolicy {
 public:
-    bool DoRetry(const baidu::rpc::Controller* cntl) const {
-        if (cntl->ErrorCode() == baidu::rpc::EHTTP && // HTTP错误
-            cntl->http_response().status_code() == baidu::rpc::HTTP_STATUS_FORBIDDEN) {
+    bool DoRetry(const brpc::Controller* cntl) const {
+        if (cntl->ErrorCode() == brpc::EHTTP && // HTTP错误
+            cntl->http_response().status_code() == brpc::HTTP_STATUS_FORBIDDEN) {
             return true;
         }
         // 把其他情况丢给框架。
-        return baidu::rpc::DefaultRetryPolicy()->DoRetry(cntl);
+        return brpc::DefaultRetryPolicy()->DoRetry(cntl);
     }
 };
 ...
  
 // 给ChannelOptions.retry_policy赋值就行了。
 // 注意：retry_policy必须在Channel使用期间保持有效，Channel也不会删除retry_policy，所以大部分情况下RetryPolicy都应以单例模式创建。
-baidu::rpc::ChannelOptions options;
+brpc::ChannelOptions options;
 static MyRetryPolicy g_my_retry_policy;
 options.retry_policy = &g_my_retry_policy;
 ...
@@ -559,13 +559,13 @@ r31468之后baidu-rpc支持[Streaming RPC](http://wiki.baidu.com/display/RPC/Str
 baas::CredentialGenerator generator = CREATE_MOCK_PERSONAL_GENERATOR(
     "mock_user", "mock_roles", "mock_group", baas::sdk::BAAS_OK);
  
-// Create a baidu::rpc::policy::GianoAuthenticator using the generator we just created 
-// and then pass it into baidu::rpc::ChannelOptions
-baidu::rpc::policy::GianoAuthenticator auth(&generator, NULL);
-baidu::rpc::ChannelOptions option;
+// Create a brpc::policy::GianoAuthenticator using the generator we just created 
+// and then pass it into brpc::ChannelOptions
+brpc::policy::GianoAuthenticator auth(&generator, NULL);
+brpc::ChannelOptions option;
 option.auth = &auth;
 ```
-首先通过调用Giano API生成验证器baas::CredentialGenerator，具体可参看[Giano快速上手手册.pdf](http://wiki.baidu.com/download/attachments/37774685/Giano%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8B%E6%89%8B%E5%86%8C.pdf?version=1&modificationDate=1421990746000&api=v2)。然后按照如上代码一步步将其设置到baidu::rpc::ChannelOptions里去。
+首先通过调用Giano API生成验证器baas::CredentialGenerator，具体可参看[Giano快速上手手册.pdf](http://wiki.baidu.com/download/attachments/37774685/Giano%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8B%E6%89%8B%E5%86%8C.pdf?version=1&modificationDate=1421990746000&api=v2)。然后按照如上代码一步步将其设置到brpc::ChannelOptions里去。
 
 当client设置认证后，任何一个新连接建立后都必须首先发送一段验证信息（通过Giano认证器生成），才能发送后续请求。认证成功后，该连接上的后续请求不会再带有验证消息。
 
@@ -581,9 +581,9 @@ set_request_compress_type()设置request的压缩方式，默认不压缩。注
 
 支持的压缩方法有：
 
-- baidu::rpc::CompressTypeSnappy : [snanpy压缩](http://google.github.io/snappy/)，压缩和解压显著快于其他压缩方法，但压缩率最低。
-- baidu::rpc::CompressTypeGzip : [gzip压缩](http://en.wikipedia.org/wiki/Gzip)，显著慢于snappy，但压缩率高
-- baidu::rpc::CompressTypeZlib : [zlib压缩](http://en.wikipedia.org/wiki/Zlib)，比gzip快10%~20%，压缩率略好于gzip，但速度仍明显慢于snappy。
+- brpc::CompressTypeSnappy : [snanpy压缩](http://google.github.io/snappy/)，压缩和解压显著快于其他压缩方法，但压缩率最低。
+- brpc::CompressTypeGzip : [gzip压缩](http://en.wikipedia.org/wiki/Gzip)，显著慢于snappy，但压缩率高
+- brpc::CompressTypeZlib : [zlib压缩](http://en.wikipedia.org/wiki/Zlib)，比gzip快10%~20%，压缩率略好于gzip，但速度仍明显慢于snappy。
 
 下表是多种压缩算法应对重复率很高的数据时的性能，仅供参考。
 

docs/cn/combo_channel.md

@@ -17,7 +17,7 @@ ParallelChannel (“pchan”)同时访问其包含的sub channel，并合并它
 
 示例代码见[example/parallel_echo_c++](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/parallel_echo_c++/)。
 
-任何baidu::rpc::ChannelBase的子类都可以加入ParallelChannel，包括ParallelChannel和其他组合Channel。用户可以设置ParallelChannelOptions.fail_limit来控制访问的最大失败次数(r31803前是ParallelChannel::set_fail_limit)，当失败的访问达到这个数目时，RPC call会立刻结束而不等待超时。
+任何brpc::ChannelBase的子类都可以加入ParallelChannel，包括ParallelChannel和其他组合Channel。用户可以设置ParallelChannelOptions.fail_limit来控制访问的最大失败次数(r31803前是ParallelChannel::set_fail_limit)，当失败的访问达到这个数目时，RPC call会立刻结束而不等待超时。
 
 当baidu-rpc >= 1.0.155.31351时，一个sub channel可多次加入同一个ParallelChannel。当你需要对同一个服务发起多次异步访问并等待它们完成的话，这很有用。
 
@@ -30,13 +30,13 @@ ParallelChannel的内部结构大致如下：
 可通过如下接口把sub channel插入ParallelChannel：
 
 ```c++
-int AddChannel(baidu::rpc::ChannelBase* sub_channel,
+int AddChannel(brpc::ChannelBase* sub_channel,
                ChannelOwnership ownership,
                CallMapper* call_mapper,
                ResponseMerger* response_merger);
 ```
 
-当ownership为baidu::rpc::OWNS_CHANNEL时，sub_channel会在ParallelChannel析构时被删除。当baidu-rpc >= 1.0.155.31351时，由于一个sub channel可能会多次加入一个ParallelChannel，只要其中一个指明了ownership为baidu::rpc::OWNS_CHANNEL，那个sub channel就会在ParallelChannel析构时被删除（一次）。
+当ownership为brpc::OWNS_CHANNEL时，sub_channel会在ParallelChannel析构时被删除。当baidu-rpc >= 1.0.155.31351时，由于一个sub channel可能会多次加入一个ParallelChannel，只要其中一个指明了ownership为brpc::OWNS_CHANNEL，那个sub channel就会在ParallelChannel析构时被删除（一次）。
 
 访问ParallelChannel时调用AddChannel是线程**不安全**的。
 
@@ -88,7 +88,7 @@ method/request/response：ParallelChannel.CallMethod()的参数。
                 const google::protobuf::MethodDescriptor* method,
                 const google::protobuf::Message* request,
                 google::protobuf::Message* response) {
-        FooRequest* copied_req = baidu::rpc::Clone<FooRequest>(request);
+        FooRequest* copied_req = brpc::Clone<FooRequest>(request);
         copied_req->set_xxx(...);
         // 拷贝并修改request，最后的flag告诉pchan在RPC结束后删除Request和Response。
         return SubCall(method, copied_req, response->New(), DELETE_REQUEST | DELETE_RESPONSE);
@@ -157,7 +157,7 @@ const Controller* sub(int index) const;
 
 示例代码见[example/selective_echo_c++](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/selective_echo_c++/)。
 
-任何baidu::rpc::ChannelBase的子类都可加入SelectiveChannel，包括SelectiveChannel和其他组合Channel。
+任何brpc::ChannelBase的子类都可加入SelectiveChannel，包括SelectiveChannel和其他组合Channel。
 
 SelectiveChannel的重试独立于其中的sub channel，当SelectiveChannel访问某个sub channel失败时（可能本身包含了重试），它会重试另外一个sub channel。
 
@@ -168,10 +168,10 @@ SelectiveChannel的重试独立于其中的sub channel，当SelectiveChannel访
 SelectiveChannel的初始化和普通Channel基本一样，但Init不需要指定名字服务，因为SelectiveChannel面向sub channel并通过AddChannel动态添加，而普通Channel面向的server才记录在名字服务中。
 
 ```c++
-#include <baidu/rpc/selective_channel.h>
+#include brpc/selective_channel.h>
 ...
-baidu::rpc::SelectiveChannel schan;
-baidu::rpc::ChannelOptions schan_options;
+brpc::SelectiveChannel schan;
+brpc::ChannelOptions schan_options;
 schan_options.timeout_ms = ...;
 schan_options.backup_request_ms = ...;
 schan_options.max_retry = ...;
@@ -194,7 +194,7 @@ if (schan.AddChannel(sub_channel, NULL/*ChannelHandle*/) != 0) {  // 第二个
 
 - 和ParallelChannel不同，SelectiveChannel的AddChannel可在任意时刻调用，即使该SelectiveChannel正在被访问（下一次访问时生效）
 - SelectiveChannel总是own sub channel，这和ParallelChannel可选择ownership是不同的。
-- 如果AddChannel第二个参数不为空，会填入一个类型为baidu::rpc::SelectiveChannel::ChannelHandle的值，这个handle可作为RemoveAndDestroyChannel的参数来动态删除一个channel。
+- 如果AddChannel第二个参数不为空，会填入一个类型为brpc::SelectiveChannel::ChannelHandle的值，这个handle可作为RemoveAndDestroyChannel的参数来动态删除一个channel。
 - SelectiveChannel会用自身的超时覆盖sub channel初始化时指定的超时。比如某个sub channel的超时为100ms，SelectiveChannel的超时为500ms，实际访问时的超时是500ms，而不是100ms。
 
 访问SelectiveChannel的方式和普通Channel是一样的。
@@ -211,8 +211,8 @@ if (schan.AddChannel(sub_channel, NULL/*ChannelHandle*/) != 0) {  // 第二个
 SelectiveChannel的创建和普通Channel类似，但不需要名字服务，而是通过AddChannel方法插入sub channel。下面的代码创建了一个SelectiveChannel，并插入三个访问不同bns的普通Channel。
 
 ```c++
-baidu::rpc::SelectiveChannel channel;
-baidu::rpc::ChannelOptions schan_options;
+brpc::SelectiveChannel channel;
+brpc::ChannelOptions schan_options;
 schan_options.timeout_ms = FLAGS_timeout_ms;
 schan_options.backup_request_ms = FLAGS_backup_ms;
 schan_options.max_retry = FLAGS_max_retry;
@@ -222,7 +222,7 @@ if (channel.Init("c_murmurhash", &schan_options) != 0) {
 }
  
 for (int i = 0; i < 3; ++i) {
-    baidu::rpc::Channel* sub_channel = new baidu::rpc::Channel;
+    brpc::Channel* sub_channel = new brpc::Channel;
     if (sub_channel->Init(bns_node_name[i], "rr", NULL) != 0) {
         LOG(ERROR) << "Fail to init sub channel " << i;
         return -1;
@@ -251,11 +251,11 @@ ParititonChannel只能处理一种分库方法，当用户需要多种分库方
 首先定制PartitionParser。这个例子中tag的形式是N/M，N代表分库的index，M是分库的个数。比如0/3代表一共3个分库，这是第一个。
 
 ```c++
-#include <baidu/rpc/partition_channel.h>
+#include brpc/partition_channel.h>
 ...
-class MyPartitionParser : public baidu::rpc::PartitionParser {
+class MyPartitionParser : public brpc::PartitionParser {
 public:
-    bool ParseFromTag(const std::string& tag, baidu::rpc::Partition* out) {
+    bool ParseFromTag(const std::string& tag, brpc::Partition* out) {
         // "N/M" : #N partition of M partitions.
         size_t pos = tag.find_first_of('/');
         if (pos == std::string::npos) {
@@ -281,11 +281,11 @@ public:
 然后初始化PartitionChannel。
 
 ```c++
-#include <baidu/rpc/partition_channel.h>
+#include brpc/partition_channel.h>
 ...
-baidu::rpc::PartitionChannel channel;
+brpc::PartitionChannel channel;
  
-baidu::rpc::PartitionChannelOptions options;
+brpc::PartitionChannelOptions options;
 options.protocol = ...;   // PartitionChannelOptions继承了ChannelOptions，后者有的前者也有
 options.timeout_ms = ...; // 同上
 options.fail_limit = 1;   // PartitionChannel自己的选项，意思同ParalellChannel中的fail_limit。这里为1的意思是只要有1个分库访问失败，这次RPC就失败了。
@@ -320,8 +320,8 @@ TRACE: 09-06 10:40:42:   * 0 server.cpp:192] S[0]=0 S[1]=0 S[2]=0 [total=0]
 
 ```c++
     ...
-    baidu::rpc::DynamicPartitionChannel channel;
-    baidu::rpc::PartitionChannelOptions options;
+    brpc::DynamicPartitionChannel channel;
+    brpc::PartitionChannelOptions options;
     options.succeed_without_server = true;          // 表示允许server_list在DynamicPartitionChannel.Init启动时为空，否则Init会失败。
     options.fail_limit = 1;                         // 任何访问分库失败都认为RPC失败。调大这个数值可以使访问更宽松，比如等于2的话表示至少两个分库失败才算失败。
     if (channel.Init(new MyPartitionParser(), "file://server_list", "rr", &options) != 0) {

docs/cn/connections.md

@@ -23,7 +23,7 @@ channel_short_socket_count: 0
 上述信息分为三段：
 
 - 第一段是server接受(accept)的连接。
-- 第二段是server与下游的单连接（使用baidu::rpc::Channel建立），fd为-1的是虚拟连接，对应第三段中所有相同RemoteSide的连接。
+- 第二段是server与下游的单连接（使用brpc::Channel建立），fd为-1的是虚拟连接，对应第三段中所有相同RemoteSide的连接。
 - 第三段是server与下游的短连接或连接池(pooled connections)，这些连接从属于第二段中的相同RemoteSide的虚拟连接。
 
 表格标题的含义：

docs/cn/cpu_profiler.md

@@ -51,20 +51,20 @@ Wrote profile to /home/gejun/pprof/echo_server.1419501210.0.0.0.0
 Removing funlockfile from all stack traces.
 Total: 2946 samples
     1161  39.4%  39.4%     1161  39.4% syscall
-     248   8.4%  47.8%      248   8.4% baidu::bthread::TaskControl::steal_task
+     248   8.4%  47.8%      248   8.4% bthread::TaskControl::steal_task
      227   7.7%  55.5%      227   7.7% writev
       87   3.0%  58.5%       88   3.0% ::cpp_alloc
       74   2.5%  61.0%       74   2.5% __read_nocancel
       46   1.6%  62.6%       48   1.6% tc_delete
-      42   1.4%  64.0%       42   1.4% baidu::rpc::Socket::Address
+      42   1.4%  64.0%       42   1.4% brpc::Socket::Address
       41   1.4%  65.4%       41   1.4% epoll_wait
       35   1.2%  66.6%       35   1.2% memcpy
       33   1.1%  67.7%       33   1.1% __pthread_getspecific
-      33   1.1%  68.8%       33   1.1% baidu::rpc::Socket::Write
+      33   1.1%  68.8%       33   1.1% brpc::Socket::Write
       33   1.1%  69.9%       33   1.1% epoll_ctl
-      28   1.0%  70.9%       42   1.4% baidu::rpc::policy::ProcessRpcRequest
-      27   0.9%  71.8%       27   0.9% baidu::IOBuf::_push_back_ref
-      27   0.9%  72.7%       27   0.9% baidu::bthread::TaskGroup::ending_sched
+      28   1.0%  70.9%       42   1.4% brpc::policy::ProcessRpcRequest
+      27   0.9%  71.8%       27   0.9% base::IOBuf::_push_back_ref
+      27   0.9%  72.7%       27   0.9% bthread::TaskGroup::ending_sched
 ```
 
 省略–text进入交互模式，如下图所示：
@@ -80,14 +80,14 @@ Welcome to pprof!  For help, type 'help'.
 (pprof) top
 Total: 2954 samples
     1099  37.2%  37.2%     1099  37.2% syscall
-     253   8.6%  45.8%      253   8.6% baidu::bthread::TaskControl::steal_task
+     253   8.6%  45.8%      253   8.6% bthread::TaskControl::steal_task
      240   8.1%  53.9%      240   8.1% writev
       90   3.0%  56.9%       90   3.0% ::cpp_alloc
       67   2.3%  59.2%       67   2.3% __read_nocancel
-      47   1.6%  60.8%       47   1.6% baidu::IOBuf::_push_back_ref
-      42   1.4%  62.2%       56   1.9% baidu::rpc::policy::ProcessRpcRequest
+      47   1.6%  60.8%       47   1.6% base::IOBuf::_push_back_ref
+      42   1.4%  62.2%       56   1.9% brpc::policy::ProcessRpcRequest
       41   1.4%  63.6%       41   1.4% epoll_wait
       38   1.3%  64.9%       38   1.3% epoll_ctl
       37   1.3%  66.1%       37   1.3% memcpy
-      35   1.2%  67.3%       35   1.2% baidu::rpc::Socket::Address
+      35   1.2%  67.3%       35   1.2% brpc::Socket::Address
 ```

docs/cn/dummy_server.md

@@ -12,14 +12,14 @@
 你必须手动加入dummy server。你得先查看[Getting Started](getting_started.md)如何下载和编译baidu-rpc，然后在程序入口处加入如下代码片段：
 
 ```c++
-#include <baidu/rpc/server.h>
+#include brpc/server.h>
  
 ...
  
 int main() {
     ...
-    baidu::rpc::Server dummy_server;
-    baidu::rpc::ServerOptions dummy_server_options;
+    brpc::Server dummy_server;
+    brpc::ServerOptions dummy_server_options;
     dummy_server_options.num_threads = 0;  // 不要改变寄主程序的线程数。
     if (dummy_server.Start(8888/*port*/, &dummy_server_options) != 0) {
         LOG(FATAL) << "Fail to start dummy server";
@@ -32,13 +32,13 @@ int main() {
 r31803之后加入dummy server更容易了，只要一行：
 
 ```c++
-#include <baidu/rpc/server.h>
+#include brpc/server.h>
  
 ...
  
 int main() {
     ...
-    baidu::rpc::StartDummyServerAt(8888/*port*/);
+    brpc::StartDummyServerAt(8888/*port*/);
     ...
 }
 ```

docs/cn/error_code.md

-baidu-rpc使用[baidu::rpc::Controller](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/controller.h)设置一次RPC的参数和获取一次RPC的结果，ErrorCode()和ErrorText()是Controller的两个方法，分别是该次RPC的错误码和错误描述，只在RPC结束后才能访问，否则结果未定义。ErrorText()由Controller的基类google::protobuf::RpcController定义，ErrorCode()则是baidu::rpc::Controller定义的。Controller还有个Failed()方法告知该次RPC是否失败，这三者的关系是：
+baidu-rpc使用[brpc::Controller](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/controller.h)设置一次RPC的参数和获取一次RPC的结果，ErrorCode()和ErrorText()是Controller的两个方法，分别是该次RPC的错误码和错误描述，只在RPC结束后才能访问，否则结果未定义。ErrorText()由Controller的基类google::protobuf::RpcController定义，ErrorCode()则是brpc::Controller定义的。Controller还有个Failed()方法告知该次RPC是否失败，这三者的关系是：
 
 - 当Failed()为true时，ErrorCode()一定不为0，ErrorText()是非空的错误描述
 - 当Failed()为false时，ErrorCode()一定为0，ErrorText()是未定义的（目前在baidu-rpc中会为空，但你最好不要依赖这个事实）

docs/cn/flags.md

@@ -117,7 +117,7 @@ r31658之后支持可视化地修改，在浏览器上访问时将看到(R)下
 
 ```c++
 DEFINE_bool(hex_log_id, false, "Show log_id in hexadecimal");
-BAIDU_RPC_VALIDATE_GFLAG(hex_log_id, baidu::rpc::PassValidate/*always true*/);
+BAIDU_RPC_VALIDATE_GFLAG(hex_log_id, brpc::PassValidate/*always true*/);
 ```
 
 这个flag是单纯的开关，修改后不需要更新其他数据（没有处理逻辑），代码中前面看到true后面看到false也不会产生什么后果（不需要线程同步），所以我们让其默认可重载。
@@ -126,7 +126,7 @@ BAIDU_RPC_VALIDATE_GFLAG(hex_log_id, baidu::rpc::PassValidate/*always true*/);
 
 ```c++
 DEFINE_int32(health_check_interval, 3, "seconds between consecutive health-checkings");
-BAIDU_RPC_VALIDATE_GFLAG(health_check_interval, baidu::rpc::PositiveInteger);
+BAIDU_RPC_VALIDATE_GFLAG(health_check_interval, brpc::PositiveInteger);
 ```
 
 以上操作都可以在命令行中进行：

docs/cn/heap_profiler.md

@@ -74,13 +74,13 @@ Total: 38.9 MB
      0.0   0.0% 100.0%      0.5   1.3% __do_global_ctors_aux
      0.0   0.0% 100.0%      1.6   4.2% _end
      0.0   0.0% 100.0%      0.5   1.3% _init
-     0.0   0.0% 100.0%      0.6   1.5% baidu::rpc::CloseIdleConnections
-     0.0   0.0% 100.0%      1.1   2.9% baidu::rpc::GlobalUpdate
-     0.0   0.0% 100.0%      0.6   1.5% baidu::rpc::PProfService::heap
-     0.0   0.0% 100.0%      1.9   4.9% baidu::rpc::Socket::Create
-     0.0   0.0% 100.0%      2.9   7.4% baidu::rpc::Socket::Write
-     0.0   0.0% 100.0%      3.8   9.7% baidu::rpc::Span::CreateServerSpan
-     0.0   0.0% 100.0%      1.4   3.5% baidu::rpc::SpanQueue::Push
+     0.0   0.0% 100.0%      0.6   1.5% brpc::CloseIdleConnections
+     0.0   0.0% 100.0%      1.1   2.9% brpc::GlobalUpdate
+     0.0   0.0% 100.0%      0.6   1.5% brpc::PProfService::heap
+     0.0   0.0% 100.0%      1.9   4.9% brpc::Socket::Create
+     0.0   0.0% 100.0%      2.9   7.4% brpc::Socket::Write
+     0.0   0.0% 100.0%      3.8   9.7% brpc::Span::CreateServerSpan
+     0.0   0.0% 100.0%      1.4   3.5% brpc::SpanQueue::Push
      0.0   0.0% 100.0%      1.9   4.8% base::ObjectPool
      0.0   0.0% 100.0%      0.8   2.0% base::ResourcePool
      0.0   0.0% 100.0%      1.0   2.6% base::iobuf::tls_block

docs/cn/http_client.md

@@ -2,13 +2,13 @@ http client的例子见[example/http_c++](http://icode.baidu.com/repo/baidu/open
 
 # 创建Channel
 
-baidu::rpc::Channel可访问HTTP服务，ChannelOptions.protocol须指定为PROTOCOL_HTTP。
+brpc::Channel可访问HTTP服务，ChannelOptions.protocol须指定为PROTOCOL_HTTP。
 
 设定为HTTP协议后，`Channel::Init`的第一个参数可为任意合法的URL。注意：允许任意URL是为了省去用户取出host和port的麻烦，`Channel::Init`只用其中的host及port，其他部分都会丢弃。
 
 ```c++
-baidu::rpc::ChannelOptions options;
-options.protocol = baidu::rpc::PROTOCOL_HTTP;
+brpc::ChannelOptions options;
+options.protocol = brpc::PROTOCOL_HTTP;
 if (channel.Init("www.baidu.com" /*any url*/, &options) != 0) {
      LOG(ERROR) << "Fail to initialize channel";
      return -1;
@@ -20,7 +20,7 @@ http channel也支持bns地址。
 # GET
 
 ```c++
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 cntl.http_request().uri() = "www.baidu.com/index.html";  // 设置为待访问的URL
 channel.CallMethod(NULL, &cntl, NULL, NULL, NULL/*done*/);
 ```
@@ -34,9 +34,9 @@ HTTP和protobuf无关，所以除了Controller和done，CallMethod的其他参
 默认的HTTP Method为GET，如果需要做POST，则需要设置。待POST的数据应置入request_attachment()，它([base::IOBuf](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/base/iobuf.h))可以直接append std::string或char*
 
 ```c++
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 cntl.http_request().uri() = "...";  // 设置为待访问的URL
-cntl.http_request().set_method(baidu::rpc::HTTP_METHOD_POST);
+cntl.http_request().set_method(brpc::HTTP_METHOD_POST);
 cntl.request_attachment().append("{\"message\":\"hello world!\"}");
 channel.CallMethod(NULL, &cntl, NULL, NULL, NULL/*done*/);
 ```
@@ -44,9 +44,9 @@ channel.CallMethod(NULL, &cntl, NULL, NULL, NULL/*done*/);
 需要大量打印过程的body建议使用base::IOBufBuilder，它的用法和std::ostringstream是一样的。对于有大量对象要打印的场景，IOBufBuilder会简化代码，并且效率也更高。
 
 ```c++
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 cntl.http_request().uri() = "...";  // 设置为待访问的URL
-cntl.http_request().set_method(baidu::rpc::HTTP_METHOD_POST);
+cntl.http_request().set_method(brpc::HTTP_METHOD_POST);
 base::IOBufBuilder os;
 os << "A lot of printing" << printable_objects << ...;
 os.move_to(cntl.request_attachment());
@@ -108,7 +108,7 @@ cntl->http_request().uri().SetQuery("Foo", "value");
 ```
 设置HTTP方法 
 ```c++
-cntl->http_request().set_method(baidu::rpc::HTTP_METHOD_POST);
+cntl->http_request().set_method(brpc::HTTP_METHOD_POST);
 ```
 设置url
 ```c++
@@ -149,19 +149,19 @@ Notes on http header:
 
 # 压缩request body
 
-在r33877后，调用Controller::set_request_compress_type(baidu::rpc::COMPRESS_TYPE_GZIP)可将http body用gzip压缩，并设置"Content-Encoding"为"gzip"。
+在r33877后，调用Controller::set_request_compress_type(brpc::COMPRESS_TYPE_GZIP)可将http body用gzip压缩，并设置"Content-Encoding"为"gzip"。
 
 # 解压response body
 
 出于通用性考虑且解压代码不复杂，baidu-rpc不会自动解压response body，用户可以自己做，方法如下：
 
 ```c++
-#include <baidu/rpc/policy/gzip_compress.h>
+#include brpc/policy/gzip_compress.h>
 ...
 const std::string* encoding = cntl->http_response().GetHeader("Content-Encoding");
 if (encoding != NULL && *encoding == "gzip") {
     base::IOBuf uncompressed;
-    if (!baidu::rpc::policy::GzipDecompress(cntl->response_attachment(), &uncompressed)) {
+    if (!brpc::policy::GzipDecompress(cntl->response_attachment(), &uncompressed)) {
         LOG(ERROR) << "Fail to un-gzip response body";
         return;
     }
@@ -181,7 +181,7 @@ r33796后baidu-rpc client支持在读取完body前就结束RPC，让用户在RPC
 1. 首先实现ProgressiveReader，接口如下：
 
    ```c++
-   #include <baidu/rpc/progressive_reader.h>
+   #include brpc/progressive_reader.h>
    ...
    class ProgressiveReader {
    public:

docs/cn/http_service.md

@@ -29,8 +29,8 @@ public:
                       const HttpRequest* /*request*/,
                       HttpResponse* /*response*/,
                       google::protobuf::Closure* done) {
-        baidu::rpc::ClosureGuard done_guard(done);
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::ClosureGuard done_guard(done);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
  
         // 这里返回纯文本。
         cntl->http_response().set_content_type("text/plain");
@@ -38,7 +38,7 @@ public:
         // 把请求的query-string和body打印出来，作为回复内容。
         base::IOBufBuilder os;
         os << "queries:";
-        for (baidu::rpc::URI::QueryIterator it = cntl->http_request().uri().QueryBegin();
+        for (brpc::URI::QueryIterator it = cntl->http_request().uri().QueryBegin();
                 it != cntl->http_request().uri().QueryEnd(); ++it) {
             os << ' ' << it->first << '=' << it->second;
         }
@@ -87,8 +87,8 @@ public:
                                 const HttpRequest* /*request*/,
                                 HttpResponse* /*response*/,
                                 google::protobuf::Closure* done) {
-        baidu::rpc::ClosureGuard done_guard(done);
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::ClosureGuard done_guard(done);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
         cntl->response_attachment().append("Getting file: ");
         cntl->response_attachment().append(cntl->http_request().unresolved_path());
     }
@@ -135,7 +135,7 @@ service QueueService {
 ```c++
 // r33521前星号只能出现在最后
 if (server.AddService(&queue_svc,
-                      baidu::rpc::SERVER_DOESNT_OWN_SERVICE,
+                      brpc::SERVER_DOESNT_OWN_SERVICE,
                       "/v1/queue/start   => start,"
                       "/v1/queue/stop    => stop,"
                       "/v1/queue/stats/* => get_stats") != 0) {
@@ -145,7 +145,7 @@ if (server.AddService(&queue_svc,
  
 // r33521后星号可出现在中间
 if (server.AddService(&queue_svc,
-                      baidu::rpc::SERVER_DOESNT_OWN_SERVICE,
+                      brpc::SERVER_DOESNT_OWN_SERVICE,
                       "/v1/*/start   => start,"
                       "/v1/*/stop    => stop,"
                       "*.data        => download_data") != 0) {
@@ -230,19 +230,19 @@ status code是http response特有的字段，标记http请求的完成情况。
 
 ```c++
 // Get Status Code
-if (cntl->http_response().status_code() == baidu::rpc::HTTP_STATUS_NOT_FOUND) {
+if (cntl->http_response().status_code() == brpc::HTTP_STATUS_NOT_FOUND) {
     LOG(FATAL) << "FAILED: " << controller.http_response().reason_phrase();
 }
 ...
 // Set Status code
-cntl->http_response().set_status_code(baidu::rpc::HTTP_STATUS_INTERNAL_SERVER_ERROR);
-cntl->http_response().set_status_code(baidu::rpc::HTTP_STATUS_INTERNAL_SERVER_ERROR, "My explanation of the error...");
+cntl->http_response().set_status_code(brpc::HTTP_STATUS_INTERNAL_SERVER_ERROR);
+cntl->http_response().set_status_code(brpc::HTTP_STATUS_INTERNAL_SERVER_ERROR, "My explanation of the error...");
 ```
 
 以下代码在302错误时重定向：
 
 ```c++
-cntl->http_response().set_status_code(baidu::rpc::HTTP_STATUS_FOUND);
+cntl->http_response().set_status_code(brpc::HTTP_STATUS_FOUND);
 cntl->http_response().SetHeader("Location", "http://bj.bs.bae.baidu.com/family/image001(4979).jpg");
 ```
 
@@ -270,19 +270,19 @@ cntl->http_request().uri().SetQuery("time", "2015/1/2");
 
 http服务常对http body进行压缩，对于文本网页可以有效减少传输时间，加快页面的展现速度。
 
-在r33093后，调用Controller::set_response_compress_type(baidu::rpc::COMPRESS_TYPE_GZIP)将尝试用gzip压缩http body，并设置"Content-Encoding"为"gzip"。“尝试”指的是如果请求中没有设置Accept-encoding或不包含gzip，压缩不会进行。比如curl不加--compressed时是不支持压缩的，这时server端总是会返回不压缩的结果。
+在r33093后，调用Controller::set_response_compress_type(brpc::COMPRESS_TYPE_GZIP)将尝试用gzip压缩http body，并设置"Content-Encoding"为"gzip"。“尝试”指的是如果请求中没有设置Accept-encoding或不包含gzip，压缩不会进行。比如curl不加--compressed时是不支持压缩的，这时server端总是会返回不压缩的结果。
 
 # 解压request body
 
 出于通用性考虑且解压代码不复杂，baidu-rpc不会自动解压request body，用户可以自己做，方法如下：
 
 ```c++
-#include <baidu/rpc/policy/gzip_compress.h>
+#include brpc/policy/gzip_compress.h>
 ...
 const std::string* encoding = cntl->http_request().GetHeader("Content-Encoding");
 if (encoding != NULL && *encoding == "gzip") {
     base::IOBuf uncompressed;
-    if (!baidu::rpc::policy::GzipDecompress(cntl->request_attachment(), &uncompressed)) {
+    if (!brpc::policy::GzipDecompress(cntl->request_attachment(), &uncompressed)) {
         LOG(ERROR) << "Fail to un-gzip request body";
         return;
     }
@@ -351,13 +351,13 @@ r33796前baidu-rpc server不适合发送超大或无限长的body。r33796后bai
 
 \1. 调用Controller::CreateProgressiveAttachment()创建可持续发送的body。
 
-`boost::intrusive_ptr<baidu::rpc::ProgressiveAttachment> pa(cntl->CreateProgressiveAttachment());`
+`boost::intrusive_ptr<brpc::ProgressiveAttachment> pa(cntl->CreateProgressiveAttachment());`
 
-返回的ProgressiveAttachment对象需要用boost::intrusive_ptr<>管理，定义在<baidu/rpc/progressive_attachment.h>中。
+返回的ProgressiveAttachment对象需要用boost::intrusive_ptr<>管理，定义在brpc/progressive_attachment.h>中。
 
 \2. 调用ProgressiveAttachment::Write()发送数据。如果写入发生在server回调结束前，发送的数据将会被缓存直到回调结束发送了header部分后才会开始发送数据。如果写入发生在server回调结束后，发送的数据将立刻以chunked mode写出。 
 
-\3. 发送完毕后确保所有的boost::intrusive_ptr<baidu::rpc::ProgressiveAttachment>都析构了。
+\3. 发送完毕后确保所有的boost::intrusive_ptr<brpc::ProgressiveAttachment>都析构了。
 
 # 持续接收
 

docs/cn/memcached_client.md

@@ -16,11 +16,11 @@
 创建一个访问memcached的Channel：
 
 ```c++
-#include <baidu/rpc/memcache.h>
-#include <baidu/rpc/channel.h>
+#include brpc/memcache.h>
+#include brpc/channel.h>
  
 ChannelOptions options;
-options.protocol = baidu::rpc::PROTOCOL_MEMCACHE;
+options.protocol = brpc::PROTOCOL_MEMCACHE;
 if (channel.Init("0.0.0.0:11211", &options) != 0) {  // 11211是memcached的默认端口
    LOG(FATAL) << "Fail to init channel to memcached";
    return -1;
@@ -34,9 +34,9 @@ if (channel.Init("0.0.0.0:11211", &options) != 0) {  // 11211是memcached的默
 
 ```c++
 // 写入key="hello" value="world" flags=0xdeadbeef，10秒失效，无视cas。
-baidu::rpc::MemcacheRequest request;
-baidu::rpc::MemcacheResponse response;
-baidu::rpc::Controller cntl;
+brpc::MemcacheRequest request;
+brpc::MemcacheResponse response;
+brpc::Controller cntl;
 if (!request.Set("hello", "world", 0xdeadbeef/*flags*/, 10/*expiring seconds*/, 0/*ignore cas*/)) {
     LOG(FATAL) << "Fail to SET request";
     return -1;

docs/cn/nshead_service.md

@@ -85,8 +85,8 @@ public:
                       const EchoRequest* request,
                       EchoResponse* response,
                       google::protobuf::Closure* done) {
-        baidu::rpc::ClosureGuard done_guard(done);
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::ClosureGuard done_guard(done);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
  
         // 填充response。
         response->set_message(request->message());
@@ -99,15 +99,15 @@ public:
                                    const MultiRequests* request,
                                    MultiResponses* response,
                                    google::protobuf::Closure* done) {
-        baidu::rpc::ClosureGuard done_guard(done);
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::ClosureGuard done_guard(done);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
  
         // 填充response。response是我们定义的包含所有idl response的消息。
         response->mutable_res1()->set_message(request->req1().message());
         response->mutable_res2()->set_message(request->req2().message());
  
         // 告诉RPC有多个request和response。
-        cntl->set_idl_names(baidu::rpc::idl_multi_req_multi_res);
+        cntl->set_idl_names(brpc::idl_multi_req_multi_res);
  
         // 对应idl方法的返回值。
         cntl->set_idl_result(17);
@@ -118,10 +118,10 @@ public:
 ## 设置ServerOptions.nshead_service
 
 ```c++
-#include <baidu/rpc/ubrpc2pb_protocol.h>
+#include brpc/ubrpc2pb_protocol.h>
 ...
-baidu::rpc::ServerOptions option;
-option.nshead_service = new baidu::rpc::policy::UbrpcCompackAdaptor; // mcpack2用UbrpcMcpack2Adaptor
+brpc::ServerOptions option;
+option.nshead_service = new brpc::policy::UbrpcCompackAdaptor; // mcpack2用UbrpcMcpack2Adaptor
 ```
 
 例子见[example/echo_c++_ubrpc_compack](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/echo_c++_ubrpc_compack/)。
@@ -147,15 +147,15 @@ public:
     virtual ~NsheadService();
  
     // 实现这个方法来处理nshead请求。注意这个方法可能在调用时controller->Failed()已经为true了。
-    // 原因可能是Server.Stop()被调用正在退出(错误码是baidu::rpc::ELOGOFF)
-    // 或触发了ServerOptions.max_concurrency(错误码是baidu::rpc::ELIMIT)
+    // 原因可能是Server.Stop()被调用正在退出(错误码是brpc::ELOGOFF)
+    // 或触发了ServerOptions.max_concurrency(错误码是brpc::ELIMIT)
     // 在这种情况下，这个方法应该通过返回一个代表错误的response让客户端知道这些错误。
     // Parameters:
     //   server      The server receiving the request.
     //   controller  Contexts of the request.
     //   request     The nshead request received.
     //   response    The nshead response that you should fill in.
-    //   done        You must call done->Run() to end the processing, baidu::rpc::ClosureGuard is preferred.
+    //   done        You must call done->Run() to end the processing, brpc::ClosureGuard is preferred.
     virtual void ProcessNsheadRequest(const Server& server,
                                       Controller* controller,
                                       const NsheadMessage& request,

docs/cn/redis_client.md

@@ -16,12 +16,12 @@ r32037后加上[-redis_verbose](http://brpc.baidu.com:8765/flags/redis_verbose;r
 创建一个访问redis的Channel：
 
 ```c++
-#include <baidu/rpc/redis.h>
-#include <baidu/rpc/channel.h>
+#include brpc/redis.h>
+#include brpc/channel.h>
   
-baidu::rpc::ChannelOptions options;
-options.protocol = baidu::rpc::PROTOCOL_REDIS;
-baidu::rpc::Channel redis_channel;
+brpc::ChannelOptions options;
+options.protocol = brpc::PROTOCOL_REDIS;
+brpc::Channel redis_channel;
 if (redis_channel.Init("0.0.0.0:6379", &options) != 0) {  // 6379是redis-server的默认端口
    LOG(ERROR) << "Fail to init channel to redis-server";
    return -1;
@@ -36,9 +36,9 @@ std::string my_key = "my_key_1";
 int my_number = 1;
 ...
 // 执行"SET <my_key> <my_number>"
-baidu::rpc::RedisRequest set_request;
-baidu::rpc::RedisResponse response;
-baidu::rpc::Controller cntl;
+brpc::RedisRequest set_request;
+brpc::RedisResponse response;
+brpc::Controller cntl;
 set_request.AddCommand("SET %s %d", my_key.c_str(), my_number);
 redis_channel.CallMethod(NULL, &cntl, &set_request, &response, NULL/*done*/);
 if (cntl.Failed()) {
@@ -56,7 +56,7 @@ LOG(INFO) << response.reply(0).c_str()  // OK
 ...
  
 // 执行"INCR <my_key>"
-baidu::rpc::RedisRequest incr_request;
+brpc::RedisRequest incr_request;
 incr_request.AddCommand("INCR %s", my_key.c_str());
 response.Clear();
 cntl.Reset();
@@ -78,9 +78,9 @@ LOG(INFO) << response.reply(0).integer()  // 2
 批量执行incr或decr
 
 ```c++
-baidu::rpc::RedisRequest request;
-baidu::rpc::RedisResponse response;
-baidu::rpc::Controller cntl;
+brpc::RedisRequest request;
+brpc::RedisResponse response;
+brpc::Controller cntl;
 request.AddCommand("INCR counter1");
 request.AddCommand("DECR counter1");
 request.AddCommand("INCRBY counter1 10");
@@ -93,7 +93,7 @@ if (cntl.Failed()) {
 CHECK_EQ(4, response.reply_size());
 for (int i = 0; i < 4; ++i) {
     CHECK(response.reply(i).is_integer());
-    CHECK_EQ(baidu::rpc::REDIS_REPLY_INTEGER, response.reply(i).type());
+    CHECK_EQ(brpc::REDIS_REPLY_INTEGER, response.reply(i).type());
 }
 CHECK_EQ(1, response.reply(0).integer());
 CHECK_EQ(0, response.reply(1).integer());

docs/cn/rpc_replay.md

@@ -56,12 +56,12 @@ serialized request (body_size - meta_size bytes, including attachment)
 baidu-rpc提供了[SampleIterator](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/rpc_dump.h)从一个采样目录下的所有文件中依次读取所有的被采样请求，用户可根据需求把serialized request反序列化为protobuf请求，做一些二次开发。
 
 ```
-#include <baidu/rpc/rpc_dump.h>
+#include brpc/rpc_dump.h>
 ...
-baidu::rpc::SampleIterator it("./rpc_data/rpc_dump/echo_server");         
+brpc::SampleIterator it("./rpc_data/rpc_dump/echo_server");         
 for (SampleRequest* req = it->Next(); req != NULL; req = it->Next()) {
     ...                    
-    // req->meta的类型是baidu::rpc::RpcDumpMeta，定义在protocol/baidu/rpc/rpc_dump.proto
+    // req->meta的类型是brpc::RpcDumpMeta，定义在protocol/baidu/rpc/rpc_dump.proto
     // req->request的类型是base::IOBuf，对应格式说明中的"serialized request"
     // 使用结束后必须delete req。
 }

docs/cn/server.md

@@ -38,9 +38,9 @@ public:
               ::example::EchoResponse* response,
               ::google::protobuf::Closure* done) {
         // 这个对象确保在return时自动调用done->Run()
-        baidu::rpc::ClosureGuard done_guard(done);
+        brpc::ClosureGuard done_guard(done);
          
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
  
         // 填写response
         response->set_message(request->message());
@@ -52,7 +52,7 @@ public:
 
 **controller**
 
-在baidu-rpc中可以静态转为baidu::rpc::Controller（前提是这运行baidu-rpc的Server中），包含了所有request和response之外的参数集合，具体接口查阅[controller.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/controller.h)
+在baidu-rpc中可以静态转为brpc::Controller（前提是这运行baidu-rpc的Server中），包含了所有request和response之外的参数集合，具体接口查阅[controller.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/controller.h)
 
 **request**
 
@@ -73,7 +73,7 @@ done包含了调用服务回调后的下一步动作，包括检查response正
 我们强烈建议使用**ClosureGuard**确保done->Run()被调用，即在服务回调开头的那句：
 
 ```c++
-baidu::rpc::ClosureGuard done_guard(done);
+brpc::ClosureGuard done_guard(done);
 ```
 
 不管在中间还是末尾脱离服务回调，都会使done_guard析构，其中会调用done->Run()。这个机制称为[RAII](https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization)。没有这个的话你得在每次return前都加上done->Run()，**极易忘记**。
@@ -90,7 +90,7 @@ public:
                  const ::example::EchoRequest* request,
                  ::example::EchoResponse* response,
                  ::google::protobuf::Closure* done) {
-         baidu::rpc::ClosureGuard done_guard(done);
+         brpc::ClosureGuard done_guard(done);
          ...
     }
  
@@ -99,7 +99,7 @@ public:
                   const ::example::EchoRequest* request,
                   ::example::EchoResponse* response,
                   ::google::protobuf::Closure* done) {
-         baidu::rpc::ClosureGuard done_guard(done);
+         brpc::ClosureGuard done_guard(done);
          ...
          done_guard.release();
     }
@@ -127,13 +127,13 @@ public:
 };
 ```
 
-> Service在插入[baidu::rpc::Server](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/server.h)后才可能提供服务。
+> Service在插入[brpc::Server](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/server.h)后才可能提供服务。
 
 ## 标记当前调用为失败
 
 调用Controller.SetFailed()可以把当前调用设置为失败，当发送过程出现错误时，框架也会调用这个函数。用户一般是在服务的CallMethod里调用这个函数，比如某个处理环节出错，SetFailed()后便可调用done->Run()并跳出函数了（如果使用了ClosureGuard的话在跳出函数时会自动调用done，不用手动）。Server端的done的逻辑主要是发送response回client，当其发现用户调用了SetFailed()后，会把错误信息送回client。client收到后，它的Controller::Failed()会为true（成功时为false），Controller::ErrorCode()和Controller::ErrorText()则分别是错误码和错误信息。
 
-对于http访问，用户还可以设置[status-code](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)，在server端一般是调用controller.http_response().set_status_code()，标准的status-code定义在[http_status_code.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/http_status_code.h)中。如果SetFailed了但没有设置status-code，默认设为baidu::rpc::HTTP_STATUS_INTERNAL_SERVER_ERROR（500错误）
+对于http访问，用户还可以设置[status-code](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)，在server端一般是调用controller.http_response().set_status_code()，标准的status-code定义在[http_status_code.h](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/http_status_code.h)中。如果SetFailed了但没有设置status-code，默认设为brpc::HTTP_STATUS_INTERNAL_SERVER_ERROR（500错误）
 
 ## 获取Client的地址和端口
 
@@ -161,7 +161,7 @@ printf("local_side=%s\n", base::endpoint2str(cntl->local_side()).c_str());
 
 即done->Run()在Service回调之外被调用。
 
-大多数Server在进入回调函数后使用baidu::rpc::ClosureGuard以确保在退出回调时done->Run()会被自动调用（向client发回response），这种是**同步service**。
+大多数Server在进入回调函数后使用brpc::ClosureGuard以确保在退出回调时done->Run()会被自动调用（向client发回response），这种是**同步service**。
 
 有些server以等待后端服务返回结果为主，且处理时间特别长，为了及时地释放出线程资源，更好的办法是把done注册到被等待事件的回调中，等到事件发生后再调用done->Run()，这种是**异步service**。
 
@@ -187,9 +187,9 @@ int AddService(google::protobuf::Service* service, ServiceOwnership ownership);
 若ownership参数为SERVER_OWNS_SERVICE，Server在析构时会一并删除Service，否则应设为SERVER_DOESNT_OWN_SERVICE。插入上节中的MyEchoService代码如下：
 
 ```c++
-baidu::rpc::Server server;
+brpc::Server server;
 MyEchoService my_echo_service;
-if (server.AddService(&my_echo_service, baidu::rpc::SERVER_DOESNT_OWN_SERVICE) != 0) {
+if (server.AddService(&my_echo_service, brpc::SERVER_DOESNT_OWN_SERVICE) != 0) {
     LOG(FATAL) << "Fail to add my_echo_service";
     return -1;
 }
@@ -213,7 +213,7 @@ int Start(const char *ip_str, PortRange port_range, const ServerOptions *opt);
 options为NULL时所有参数取默认值，如果你要使用非默认值，这么做就行了：
 
 ```c++
-baidu::rpc::ServerOptions options;  // 包含了默认值
+brpc::ServerOptions options;  // 包含了默认值
 options.xxx = yyy;
 ...
 server.Start(..., &options);
@@ -280,14 +280,14 @@ r34532后增加选项-pb_enum_as_number，开启后pb中的enum会转化为它
 15年时，baidu-rpc允许一个pb service被http协议访问时，不设置pb请求，即使里面有required字段。一般来说这种service会自行解析http请求和设置http回复，并不会访问pb请求。但这也是非常危险的行为，毕竟这是pb service，但pb请求却是未定义的。这种服务在升级到新版本rpc时会遇到障碍，因为baidu-rpc早不允许这种行为。为了帮助这种服务升级，r34953后baidu-rpc允许用户经过一些设置后不把http body自动转化为pb（从而可自行处理），方法如下：
 
 ```c++
-baidu::rpc::ServiceOptions svc_opt;
+brpc::ServiceOptions svc_opt;
 svc_opt.ownership = ...;
 svc_opt.restful_mappings = ...;
 svc_opt.allow_http_body_to_pb = false; //关闭http body至pb的自动转化
 server.AddService(service, svc_opt);
 ```
 
-如此设置后service收到http请求后不会尝试把body转化为pb请求，所以pb请求总是未定义状态，用户得根据`cntl->request_protocol() == baidu::rpc::PROTOCOL_HTTP`来判断请求是否是http，并自行对http body进行解析。
+如此设置后service收到http请求后不会尝试把body转化为pb请求，所以pb请求总是未定义状态，用户得根据`cntl->request_protocol() == brpc::PROTOCOL_HTTP`来判断请求是否是http，并自行对http body进行解析。
 
 相应地，r34953中当cntl->response_attachment()不为空时（且pb回复不为空），框架不再报错，而是直接把cntl->response_attachment()作为回复的body。这个功能和设置allow_http_body_to_pb与否无关，如果放开自由度导致过多的用户犯错，可能会有进一步的调整。
 
@@ -306,31 +306,31 @@ server端会自动尝试其支持的协议，无需用户指定。`cntl->protoco
 - nova协议，显示为”nova“ (r32206前显示为"nshead_server")，默认不启用，开启方式：
 
   ```c++
-  #include <baidu/rpc/policy/nova_pbrpc_protocol.h>
+  #include brpc/policy/nova_pbrpc_protocol.h>
   ...
   ServerOptions options;
   ...
-  options.nshead_service = new baidu::rpc::policy::NovaServiceAdaptor;
+  options.nshead_service = new brpc::policy::NovaServiceAdaptor;
   ```
 
 - public/pbrpc协议，显示为"public_pbrpc" (r32206前显示为"nshead_server")，默认不启用，开启方式：
 
   ```c++
-  #include <baidu/rpc/policy/public_pbrpc_protocol.h>
+  #include brpc/policy/public_pbrpc_protocol.h>
   ...
   ServerOptions options;
   ...
-  options.nshead_service = new baidu::rpc::policy::PublicPbrpcServiceAdaptor;
+  options.nshead_service = new brpc::policy::PublicPbrpcServiceAdaptor;
   ```
 
 - nshead_mcpack协议，显示为"nshead_mcpack"，默认不启用，开启方式：
 
   ```c++
-  #include <baidu/rpc/policy/nshead_mcpack_protocol.h>
+  #include brpc/policy/nshead_mcpack_protocol.h>
   ...
   ServerOptions options;
   ...
-  options.nshead_service = new baidu::rpc::policy::NsheadMcpackAdaptor;
+  options.nshead_service = new brpc::policy::NsheadMcpackAdaptor;
   ```
 
   顾名思义，这个协议的数据包由nshead+mcpack构成，mcpack中不包含特殊字段。不同于用户基于NsheadService的实现，这个协议使用了mcpack2pb：任何protobuf service都可以接受这个协议的请求。由于没有传递ErrorText的字段，当发生错误时server只能关闭连接。
@@ -397,9 +397,9 @@ set_response_compress_type()设置response的压缩方式，默认不压缩。
 
 支持的压缩方法有：
 
-- baidu::rpc::CompressTypeSnappy : [snanpy压缩](http://google.github.io/snappy/)，压缩和解压显著快于其他压缩方法，但压缩率最低。
-- baidu::rpc::CompressTypeGzip : [gzip压缩](http://en.wikipedia.org/wiki/Gzip)，显著慢于snappy，但压缩率高
-- baidu::rpc::CompressTypeZlib : [zlib压缩](http://en.wikipedia.org/wiki/Zlib)，比gzip快10%~20%，压缩率略好于gzip，但速度仍明显慢于snappy。
+- brpc::CompressTypeSnappy : [snanpy压缩](http://google.github.io/snappy/)，压缩和解压显著快于其他压缩方法，但压缩率最低。
+- brpc::CompressTypeGzip : [gzip压缩](http://en.wikipedia.org/wiki/Gzip)，显著慢于snappy，但压缩率高
+- brpc::CompressTypeZlib : [zlib压缩](http://en.wikipedia.org/wiki/Zlib)，比gzip快10%~20%，压缩率略好于gzip，但速度仍明显慢于snappy。
 
 更具体的性能对比见[Client-压缩](client.md#压缩).
 
@@ -454,10 +454,10 @@ server端开启giano认证的方式：
 // Create a baas::CredentialVerifier using Giano's API
 baas::CredentialVerifier verifier = CREATE_MOCK_VERIFIER(baas::sdk::BAAS_OK);
  
-// Create a baidu::rpc::policy::GianoAuthenticator using the verifier we just created 
-// and then pass it into baidu::rpc::ServerOptions
-baidu::rpc::policy::GianoAuthenticator auth(NULL, &verifier);
-baidu::rpc::ServerOptions option;
+// Create a brpc::policy::GianoAuthenticator using the verifier we just created 
+// and then pass it into brpc::ServerOptions
+brpc::policy::GianoAuthenticator auth(NULL, &verifier);
+brpc::ServerOptions option;
 option.auth = &auth;
 ```
 
@@ -559,7 +559,7 @@ server.MaxConcurrencyOf(&service, "Echo") = 10;
 
 ### 对返回的URL进行转义
 
-可调用baidu::rpc::WebEscape()对url进行转义，防止恶意URI注入攻击。
+可调用brpc::WebEscape()对url进行转义，防止恶意URI注入攻击。
 
 ### 不返回内部server地址
 
@@ -595,7 +595,7 @@ public:
               example::EchoResponse* response,
               google::protobuf::Closure* done) {
         ...
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
  
         // Get the session-local data which is created by ServerOptions.session_local_data_factory
         // and reused between different RPC.
@@ -637,7 +637,7 @@ session_local_data_factory的类型为[DataFactory](http://icode.baidu.com/repo/
 注意：CreateData和DestroyData会被多个线程同时调用，必须线程安全。
 
 ```c++
-class MySessionLocalDataFactory : public baidu::rpc::DataFactory {
+class MySessionLocalDataFactory : public brpc::DataFactory {
 public:
     void* CreateData() const {
         return new MySessionLocalData;
@@ -651,8 +651,8 @@ int main(int argc, char* argv[]) {
     ...
     MySessionLocalDataFactory session_local_data_factory;
  
-    baidu::rpc::Server server;
-    baidu::rpc::ServerOptions options;
+    brpc::Server server;
+    brpc::ServerOptions options;
     ...
     options.session_local_data_factory = &session_local_data_factory;
     ...
@@ -678,12 +678,12 @@ public:
               example::EchoResponse* response,
               google::protobuf::Closure* done) {
         ...
-        baidu::rpc::Controller* cntl = static_cast<baidu::rpc::Controller*>(cntl_base);
+        brpc::Controller* cntl = static_cast<brpc::Controller*>(cntl_base);
          
         // Get the thread-local data which is created by ServerOptions.thread_local_data_factory
         // and reused between different threads.
         // "tls" is short for "thread local storage".
-        MyThreadLocalData* tls = static_cast<MyThreadLocalData*>(baidu::rpc::thread_local_data());
+        MyThreadLocalData* tls = static_cast<MyThreadLocalData*>(brpc::thread_local_data());
         if (tls == NULL) {
             cntl->SetFailed("Require ServerOptions.thread_local_data_factory "
                             "to be set with a correctly implemented instance");
@@ -701,13 +701,13 @@ struct ServerOptions {
     ...    
     // The factory to create/destroy data attached to each searching thread
     // in server.
-    // If this field is NULL, baidu::rpc::thread_local_data() is always NULL.
+    // If this field is NULL, brpc::thread_local_data() is always NULL.
     // NOT owned by Server and must be valid when Server is running.
     // Default: NULL
     const DataFactory* thread_local_data_factory;
  
     // Prepare so many thread-local data before server starts, so that calls
-    // to baidu::rpc::thread_local_data() get data directly rather than calling
+    // to brpc::thread_local_data() get data directly rather than calling
     // thread_local_data_factory->Create() at first time. Useful when Create()
     // is slow, otherwise the RPC session may be blocked by the creation
     // of data and not served within timeout.
@@ -723,7 +723,7 @@ thread_local_data_factory的类型为[DataFactory](http://icode.baidu.com/repo/b
 注意：CreateData和DestroyData会被多个线程同时调用，必须线程安全。
 
 ```c++
-class MyThreadLocalDataFactory : public baidu::rpc::DataFactory {
+class MyThreadLocalDataFactory : public brpc::DataFactory {
 public:
     void* CreateData() const {
         return new MyThreadLocalData;
@@ -737,8 +737,8 @@ int main(int argc, char* argv[]) {
     ...
     MyThreadLocalDataFactory thread_local_data_factory;
  
-    baidu::rpc::Server server;
-    baidu::rpc::ServerOptions options;
+    brpc::Server server;
+    brpc::ServerOptions options;
     ...
     options.thread_local_data_factory  = &thread_local_data_factory;
     ...

docs/cn/status.md

@@ -18,13 +18,13 @@
 - **processing**: 正在处理的请求个数。如果持续不为0（特别是在压力归0后），应考虑程序是否有bug。
 
 
-用户可通过让对应Service实现[baidu::rpc::Describable](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/describable.h)自定义在/status页面上的描述.
+用户可通过让对应Service实现[brpc::Describable](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/src/brpc/describable.h)自定义在/status页面上的描述.
 
 ```c++
-class MyService : public XXXService, public baidu::rpc::Describable {
+class MyService : public XXXService, public brpc::Describable {
 public:
     ...
-    void DescribeStatus(std::ostream& os, const baidu::rpc::DescribeOptions& options) const {
+    void DescribeStatus(std::ostream& os, const brpc::DescribeOptions& options) const {
         os << "my_status: blahblah";
     }
 };

docs/cn/ub_client.md

@@ -75,13 +75,13 @@ r31687后，baidu-rpc支持通过protobuf访问ubrpc，不需要baidu-rpc-ub，
    idl不同于pb，允许有多个请求，我们先看只有一个请求的情况，和普通的pb访问基本上是一样的。
 
    ```c++
-   #include <baidu/rpc/channel.h>
+   #include brpc/channel.h>
    #include "echo.pb.h"
    ...
     
-   baidu::rpc::Channel channel;
-   baidu::rpc::ChannelOptions opt;
-   opt.protocol = baidu::rpc::PROTOCOL_UBRPC_COMPACK; // or "ubrpc_compack";
+   brpc::Channel channel;
+   brpc::ChannelOptions opt;
+   opt.protocol = brpc::PROTOCOL_UBRPC_COMPACK; // or "ubrpc_compack";
    if (channel.Init(..., &opt) != 0) {
        LOG(ERROR) << "Fail to init channel";
        return -1;
@@ -91,7 +91,7 @@ r31687后，baidu-rpc支持通过protobuf访问ubrpc，不需要baidu-rpc-ub，
     
    EchoRequest request;
    EchoResponse response;
-   baidu::rpc::Controller cntl;
+   brpc::Controller cntl;
     
    request.set_message("hello world");
     
@@ -110,13 +110,13 @@ r31687后，baidu-rpc支持通过protobuf访问ubrpc，不需要baidu-rpc-ub，
    多个请求要设置一下set_idl_names。
 
    ```c++
-   #include <baidu/rpc/channel.h>
+   #include brpc/channel.h>
    #include "echo.pb.h"
    ...
     
-   baidu::rpc::Channel channel;
-   baidu::rpc::ChannelOptions opt;
-   opt.protocol = baidu::rpc::PROTOCOL_UBRPC_COMPACK; // or "ubrpc_compack";
+   brpc::Channel channel;
+   brpc::ChannelOptions opt;
+   opt.protocol = brpc::PROTOCOL_UBRPC_COMPACK; // or "ubrpc_compack";
    if (channel.Init(..., &opt) != 0) {
        LOG(ERROR) << "Fail to init channel";
        return -1;
@@ -126,11 +126,11 @@ r31687后，baidu-rpc支持通过protobuf访问ubrpc，不需要baidu-rpc-ub，
     
    MultiRequests multi_requests;
    MultiResponses multi_responses;
-   baidu::rpc::Controller cntl;
+   brpc::Controller cntl;
     
    multi_requests.mutable_req1()->set_message("hello");
    multi_requests.mutable_req2()->set_message("world");
-   cntl.set_idl_names(baidu::rpc::idl_multi_req_multi_res);
+   cntl.set_idl_names(brpc::idl_multi_req_multi_res);
    stub.EchoWithMultiArgs(&cntl, &multi_requests, &multi_responses, NULL);
         
    if (cntl.Failed()) {
@@ -154,7 +154,7 @@ server端由public/ubrpc搭建，request/response使用idl文件描述字段，
 
 **步骤：**
 
-1. 依赖[public/baidu-rpc-ub](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob-ub)模块，在COMAKE中增加依赖：`CONFIGS('public/baidu-rpc-ub@ci-base')。`这个模块是baidu-rpc的扩展，不需要的用户不会依赖idl/mcpack/compack等模块。baidu-rpc-ub只包含扩展代码，baidu-rpc中的新特性会自动体现在这个模块中。
+1. 依赖[public/baidu-rpc-ub](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob)模块，在COMAKE中增加依赖：`CONFIGS('public/baidu-rpc-ub@ci-base')。`这个模块是baidu-rpc的扩展，不需要的用户不会依赖idl/mcpack/compack等模块。baidu-rpc-ub只包含扩展代码，baidu-rpc中的新特性会自动体现在这个模块中。
 
 2. 编写一个proto文件，其中定义了service，名字和idl中的相同，但请求类型必须是baidu.rpc.UBRequest，回复类型必须是baidu.rpc.UBResponse。这两个类型定义在baidu/rpc/ub.proto中，使用时得import。
 
@@ -175,15 +175,15 @@ server端由public/ubrpc搭建，request/response使用idl文件描述字段，
    PROTOFLAGS("--proto_path=" + ENV.WorkRoot() + "public/baidu-rpc-ub/src/")
    ```
 
-4. 用法和访问其他协议类似：创建Channel，ChannelOptions.protocol为**baidu::rpc::PROTOCOL_NSHEAD_CLIENT**或**"nshead_client"**。request和response对象必须是baidu-rpc-ub提供的类型
+4. 用法和访问其他协议类似：创建Channel，ChannelOptions.protocol为**brpc::PROTOCOL_NSHEAD_CLIENT**或**"nshead_client"**。request和response对象必须是baidu-rpc-ub提供的类型
 
    ```c++
-   #include <baidu/rpc/ub_call.h>
+   #include brpc/ub_call.h>
    ...
        
-   baidu::rpc::Channel channel;
-   baidu::rpc::ChannelOptions opt;
-   opt.protocol = baidu::rpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client";
+   brpc::Channel channel;
+   brpc::ChannelOptions opt;
+   opt.protocol = brpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client";
    if (channel.Init(..., &opt) != 0) {
        LOG(ERROR) << "Fail to init channel";
        return -1;
@@ -200,14 +200,14 @@ server端由public/ubrpc搭建，request/response使用idl文件描述字段，
    }
     
    // 构造UBRPC的request/response，idl结构体作为模块参数传入。为了构造idl结构，需要传入一个bsl::mempool
-   baidu::rpc::UBRPCCompackRequest<example::EchoService_Echo_params> request(&pool);
-   baidu::rpc::UBRPCCompackResponse<example::EchoService_Echo_response> response(&pool);
+   brpc::UBRPCCompackRequest<example::EchoService_Echo_params> request(&pool);
+   brpc::UBRPCCompackResponse<example::EchoService_Echo_response> response(&pool);
     
    // 设置字段
    request.mutable_req()->set_message("hello world");
     
    // 发起RPC
-   baidu::rpc::Controller cntl;
+   brpc::Controller cntl;
    stub.Echo(&cntl, &request, &response, NULL);
        
    if (cntl.Failed()) {
@@ -219,7 +219,7 @@ server端由public/ubrpc搭建，request/response使用idl文件描述字段，
    ...
    ```
 
-   具体example代码可以参考[echo_c++_compack_ubrpc](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob-ub/example/echo_c++_compack_ubrpc/)，类似的还有[echo_c++_mcpack_ubrpc](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob-ub/example/echo_c++_mcpack_ubrpc/)。
+   具体example代码可以参考[echo_c++_compack_ubrpc](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/echo_c++_compack_ubrpc/)，类似的还有[echo_c++_mcpack_ubrpc](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/echo_c++_mcpack_ubrpc/)。
 
 # nshead+idl
 
@@ -228,12 +228,12 @@ server端是由public/ub搭建，通讯包组成为nshead+idl::compack/idl::mcpa
 由于不需要指定service和method，无需编写proto文件，直接使用Channel.CallMethod方法发起RPC即可。请求包中的nshead可以填也可以不填，框架会补上正确的magic_num和body_len字段：
 
 ```c++
-#include <baidu/rpc/ub_call.h>
+#include brpc/ub_call.h>
 ...
  
-baidu::rpc::Channel channel;
-baidu::rpc::ChannelOptions opt;
-opt.protocol = baidu::rpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client";
+brpc::Channel channel;
+brpc::ChannelOptions opt;
+opt.protocol = brpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client";
  
 if (channel.Init(..., &opt) != 0) {
     LOG(ERROR) << "Fail to init channel";
@@ -243,34 +243,34 @@ if (channel.Init(..., &opt) != 0) {
  
 // 构造UB的request/response，完全类似构造原先idl结构，传入一个bsl::mempool（变量pool）
 // 将类型作为模板传入，之后在使用上可以直接使用对应idl结构的接口
-baidu::rpc::UBCompackRequest<example::EchoRequest> request(&pool);
-baidu::rpc::UBCompackResponse<example::EchoResponse> response(&pool);
+brpc::UBCompackRequest<example::EchoRequest> request(&pool);
+brpc::UBCompackResponse<example::EchoResponse> response(&pool);
  
 // Set `message' field of `EchoRequest'
 request.set_message("hello world");
 // Set fields of the request nshead struct if needed
 request.mutable_nshead()->version = 99;
  
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 channel.CallMethod(NULL, &cntl, &request, &response, NULL);    // 假设channel已经通过之前所述方法Init成功
  
 // Get `message' field of `EchoResponse'
 response.message();
 ```
 
-具体example代码可以参考[echo_c++_mcpack_ub](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob-ub/example/echo_c++_mcpack_ub/)，compack情况类似，不再赘述
+具体example代码可以参考[echo_c++_mcpack_ub](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/echo_c++_mcpack_ub/)，compack情况类似，不再赘述
 
 # nshead+mcpack(非idl产生的)
 
 server端是由public/ub搭建，通讯包组成为nshead+mcpack包，但不是idl编译器生成的，RPC前需要先构造RawBuffer将其传入，然后获取mc_pack_t并按之前手工填写mcpack的方式操作：
 
 ```c++
-#include <baidu/rpc/ub_call.h>
+#include brpc/ub_call.h>
 ...
  
-baidu::rpc::Channel channel;
-baidu::rpc::ChannelOptions opt;
-opt.protocol = baidu::rpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client";
+brpc::Channel channel;
+brpc::ChannelOptions opt;
+opt.protocol = brpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client";
 if (channel.Init(..., &opt) != 0) {
     LOG(ERROR) << "Fail to init channel";
     return -1;
@@ -279,12 +279,12 @@ if (channel.Init(..., &opt) != 0) {
  
 // 构造RawBuffer，一次RPC结束后RawBuffer可以复用，类似于bsl::mempool
 const int BUFSIZE = 10 * 1024 * 1024;
-baidu::rpc::RawBuffer req_buf(BUFSIZE);
-baidu::rpc::RawBuffer res_buf(BUFSIZE);
+brpc::RawBuffer req_buf(BUFSIZE);
+brpc::RawBuffer res_buf(BUFSIZE);
  
 // 传入RawBuffer来构造request和response
-baidu::rpc::UBRawMcpackRequest request(&req_buf);
-baidu::rpc::UBRawMcpackResponse response(&res_buf);
+brpc::UBRawMcpackRequest request(&req_buf);
+brpc::UBRawMcpackResponse response(&res_buf);
          
 // Fetch mc_pack_t and fill in variables
 mc_pack_t* req_pack = request.McpackHandle();
@@ -297,7 +297,7 @@ if (ret != 0) {
 // Set fields of the request nshead struct if needed
 request.mutable_nshead()->version = 99;
  
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 channel.CallMethod(NULL, &cntl, &request, &response, NULL);    // 假设channel已经通过之前所述方法Init成功
  
 // Get response from response buffer
@@ -305,26 +305,26 @@ const mc_pack_t* res_pack = response.McpackHandle();
 mc_pack_get_str(res_pack, "mystr");
 ```
 
-具体example代码可以参考[echo_c++_raw_mcpack](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob-ub/example/echo_c++_raw_mcpack/)。
+具体example代码可以参考[echo_c++_raw_mcpack](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/echo_c++_raw_mcpack/)。
 
 # nshead+blob
 
 r32897后baidu-rpc直接支持用nshead+blob访问老server（而不用依赖baidu-rpc-ub）。example代码可以参考[nshead_extension_c++](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/nshead_extension_c++/client.cpp)。
 
 ```c++
-#include <baidu/rpc/nshead_message.h>
+#include brpc/nshead_message.h>
 ...
  
-baidu::rpc::Channel;
-baidu::rpc::ChannelOptions opt;
-opt.protocol = baidu::rpc::PROTOCOL_NSHEAD; // or "nshead"
+brpc::Channel;
+brpc::ChannelOptions opt;
+opt.protocol = brpc::PROTOCOL_NSHEAD; // or "nshead"
 if (channel.Init(..., &opt) != 0) {
     LOG(ERROR) << "Fail to init channel";
     return -1;
 } 
 ...
-baidu::rpc::NsheadMessage request;
-baidu::rpc::NsheadMessage response;
+brpc::NsheadMessage request;
+brpc::NsheadMessage response;
        
 // Append message to `request'
 request.body.append("hello world");
@@ -332,7 +332,7 @@ request.body.append("hello world");
 request.head.version = 99;
  
  
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 channel.CallMethod(NULL, &cntl, &request, &response, NULL);
  
 if (cntl.Failed()) {
@@ -342,12 +342,12 @@ if (cntl.Failed()) {
 // response.head and response.body contains nshead_t and blob respectively.
 ```
 
-或者用户也可以使用baidu-rpc-ub中的UBRawBufferRequest和UBRawBufferResponse来访问。example代码可以参考[echo_c++_raw_buffer](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob-ub/example/echo_c++_raw_buffer/)。
+或者用户也可以使用baidu-rpc-ub中的UBRawBufferRequest和UBRawBufferResponse来访问。example代码可以参考[echo_c++_raw_buffer](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/blob/example/echo_c++_raw_buffer/)。
 
 ```c++
-baidu::rpc::Channel channel;
-baidu::rpc::ChannelOptions opt;
-opt.protocol = baidu::rpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client"
+brpc::Channel channel;
+brpc::ChannelOptions opt;
+opt.protocol = brpc::PROTOCOL_NSHEAD_CLIENT; // or "nshead_client"
 if (channel.Init(..., &opt) != 0) {
     LOG(ERROR) << "Fail to init channel";
     return -1;
@@ -356,19 +356,19 @@ if (channel.Init(..., &opt) != 0) {
  
 // 构造RawBuffer，一次RPC结束后RawBuffer可以复用，类似于bsl::mempool
 const int BUFSIZE = 10 * 1024 * 1024;
-baidu::rpc::RawBuffer req_buf(BUFSIZE);
-baidu::rpc::RawBuffer res_buf(BUFSIZE);
+brpc::RawBuffer req_buf(BUFSIZE);
+brpc::RawBuffer res_buf(BUFSIZE);
  
 // 传入RawBuffer来构造request和response
-baidu::rpc::UBRawBufferRequest request(&req_buf);
-baidu::rpc::UBRawBufferResponse response(&res_buf);
+brpc::UBRawBufferRequest request(&req_buf);
+brpc::UBRawBufferResponse response(&res_buf);
          
 // Append message to `request'
 request.append("hello world");
 // Set fields of the request nshead struct if needed
 request.mutable_nshead()->version = 99;
  
-baidu::rpc::Controller cntl;
+brpc::Controller cntl;
 channel.CallMethod(NULL, &cntl, &request, &response, NULL);    // 假设channel已经通过之前所述方法Init成功
  
 // Process response. response.data() is the buffer, response.size() is the length.

docs/cn/vars.md

-[public/bvar](../src/bvar/)是多线程环境下的计数器类库，方便记录和查看用户程序中的各类数值，它利用了thread local存储避免了cache bouncing，相比UbMonitor几乎不会给程序增加性能开销，也快于竞争频繁的原子操作。baidu-rpc集成了bvar，[/vars](http://brpc.baidu.com:8765/vars)可查看所有曝光的bvar，[/vars/VARNAME](http://brpc.baidu.com:8765/vars/rpc_socket_count)可查阅某个bvar，增加计数器的方法请查看[bvar](http://wiki.baidu.com/display/RPC/bvar)。baidu-rpc大量使用了bvar提供统计数值，当你需要在多线程环境中计数并展现时，应该第一时间想到bvar。但bvar不能代替所有的计数器，它的本质是把写时的竞争转移到了读：读得合并所有写过的线程中的数据，而不可避免地变慢了。当你读写都很频繁并得基于数值做一些逻辑判断时，你不应该用bvar。
+[public/bvar](http://icode.baidu.com/repo/baidu/opensource/baidu-rpc/files/master/tree/src/bvar/)是多线程环境下的计数器类库，方便记录和查看用户程序中的各类数值，它利用了thread local存储避免了cache bouncing，相比UbMonitor几乎不会给程序增加性能开销，也快于竞争频繁的原子操作。baidu-rpc集成了bvar，[/vars](http://brpc.baidu.com:8765/vars)可查看所有曝光的bvar，[/vars/VARNAME](http://brpc.baidu.com:8765/vars/rpc_socket_count)可查阅某个bvar，增加计数器的方法请查看[bvar](http://wiki.baidu.com/display/RPC/bvar)。baidu-rpc大量使用了bvar提供统计数值，当你需要在多线程环境中计数并展现时，应该第一时间想到bvar。但bvar不能代替所有的计数器，它的本质是把写时的竞争转移到了读：读得合并所有写过的线程中的数据，而不可避免地变慢了。当你读写都很频繁并得基于数值做一些逻辑判断时，你不应该用bvar。
 
 ## 查询方法