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。
 
 下表是多种压缩算法应对重复率很高的数据时的性能，仅供参考。
 
@@ -663,4 +663,4 @@ FATAL 04-07 20:00:03 7778 public/baidu-rpc/src/baidu/rpc/channel.cpp:123] Invali
 
 ### Q: 为什么C++ client/server 能够互相通信， 和其他语言的client/server 通信会报序列化失败的错误
 
-检查一下C++ 版本是否开启了压缩 (Controller::set_compress_type), 目前 python/JAVA版的rpc框架还没有实现压缩，互相返回会出现问题。 
\ No newline at end of file
+检查一下C++ 版本是否开启了压缩 (Controller::set_compress_type), 目前 python/JAVA版的rpc框架还没有实现压缩，互相返回会出现问题。 

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/getting_started.md

@@ -97,4 +97,4 @@ baidu-rpc detects valgrind automatically (and registers stacks of bthread). Olde
 
 # Track instances
 
-We provide a program to help you to track and monitor all baidu-rpc instances. Just run [trackme_server](tools/trackme_server/trackme_server.cpp) somewhere and launch need-to-be-tracked instances with -trackme_server=<SERVER>. The trackme_server will receive pings from instance periodically and print logs when it does. You can aggregate instance addresses from the log and call builtin services of the instances for further information.
\ No newline at end of file
+We provide a program to help you to track and monitor all baidu-rpc instances. Just run [trackme_server](tools/trackme_server/trackme_server.cpp) somewhere and launch need-to-be-tracked instances with -trackme_server=<SERVER>. The trackme_server will receive pings from instance periodically and print logs when it does. You can aggregate instance addresses from the log and call builtin services of the instances for further information.

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。
 
 ## 查询方法