├── .gitignore
├── .gitmodules
├── TODO
├── ucorf
    ├── option.h
    ├── ucorf.h
    ├── preheader.h
    ├── hprose
    │   ├── hprose_message.h
    │   ├── hprose_message.cpp
    │   ├── hprose_header.h
    │   ├── hprose_header.cpp
    │   ├── hprose_service.cpp
    │   ├── hprose_service.h
    │   └── hprose_protocol.h
    ├── url.h
    ├── server_register.h
    ├── service.h
    ├── pb_message.h
    ├── pb_message.cpp
    ├── error.h
    ├── server.h
    ├── client.h
    ├── pb_service.h
    ├── server.cpp
    ├── server_register.cpp
    ├── client.cpp
    ├── error.cpp
    ├── transport.h
    ├── pb_service.cpp
    ├── net_transport.h
    ├── server_impl.h
    ├── dispatcher.h
    ├── message.h
    ├── server_finder.h
    ├── conhash.h
    ├── zookeeper.h
    ├── message.cpp
    ├── dispatcher.cpp
    ├── logger.h
    ├── client_impl.h
    ├── logger.cpp
    ├── net_transport.cpp
    ├── server_impl.cpp
    ├── server_finder.cpp
    ├── client_impl.cpp
    └── zookeeper.cpp
├── test
    ├── echo.proto
    ├── hprose_client.cpp
    ├── server.cpp
    ├── hprose_server.cpp
    ├── zk_client.cpp
    ├── CMakeLists.txt
    ├── client.cpp
    ├── zk_server.cpp
    ├── bmserver.cpp
    ├── hprose_bmserver.cpp
    ├── wnd_client.cpp
    ├── hprose_bmclient.cpp
    └── bmclient.cpp
├── samples
    ├── sample1_server.cpp
    ├── sample3_client.cpp
    ├── sample2_server.cpp
    ├── sample1_client.cpp
    ├── sample3_server.cpp
    ├── CMakeLists.txt
    ├── sample2_client.cpp
    └── sample4_client.cpp
├── CMakeLists.txt
├── README.md
└── proto_gen
    ├── protoc-gen-rpc
    ├── plugin_pb2.py
    ├── plugin.proto
    └── descriptor.proto


/.gitignore:
--------------------------------------------------------------------------------
1 | build/*
2 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "third_party/libgonet"]
2 | 	path = third_party/libgonet
3 | 	url = https://github.com/yyzybb537/libgonet.git
4 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
 1 | TODO:
 2 | 提供查询RPC直接的srv和interface功能
 3 | 提供rpc接口版本号校验, 检验interface签名
 4 | 
 5 | DONE:
 6 | 增加调试log模块, 输出链接相关信息
 7 | 解决并发超过500导致的频繁错误问题(内核参数导致的问题)
 8 | ZK服务注册与发现
 9 | single client的retry bug.
10 | 一致性hash负载均衡
11 | 增加过载保护机制
12 | Log模块的reopen改为线程安全
13 | 


--------------------------------------------------------------------------------
/ucorf/option.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     struct Option
 8 |     {
 9 |         std::size_t request_wnd_size = -1;
10 |         int rcv_timeout_ms = 10000;
11 |         boost::any transport_opt;
12 |     };
13 | 
14 | } //namespace ucorf
15 | 


--------------------------------------------------------------------------------
/test/echo.proto:
--------------------------------------------------------------------------------
 1 | package Echo;
 2 | 
 3 | option cc_generic_services = true;
 4 | 
 5 | message EchoRequest
 6 | {
 7 |     required int32 code = 1;
 8 | };
 9 | 
10 | message EchoResponse
11 | {
12 |     required int32 code = 1;
13 | };
14 | 
15 | service EchoService
16 | {
17 |     rpc Echo(EchoRequest) returns(EchoResponse);
18 | };
19 | 


--------------------------------------------------------------------------------
/ucorf/ucorf.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "message.h"
 5 | #include "pb_message.h"
 6 | #include "error.h"
 7 | #include "logger.h"
 8 | #include "option.h"
 9 | #include "dispatcher.h"
10 | #include "transport.h"
11 | #include "net_transport.h"
12 | #include "server_finder.h"
13 | #include "server_register.h"
14 | #include "service.h"
15 | #include "pb_service.h"
16 | #include "zookeeper.h"
17 | #include "conhash.h"
18 | #include "server.h"
19 | #include "client.h"
20 | 
21 | 


--------------------------------------------------------------------------------
/ucorf/preheader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <map>
 5 | #include <list>
 6 | #include <atomic>
 7 | #include <chrono>
 8 | #include <unordered_map>
 9 | #include <boost/shared_ptr.hpp>
10 | #include <boost/make_shared.hpp>
11 | #include <boost/function.hpp>
12 | #include <boost/bind.hpp>
13 | #include <boost/system/error_code.hpp>
14 | #include <boost/any.hpp>
15 | #include <libgo/coroutine.h>
16 | 
17 | // linux
18 | #include <arpa/inet.h>
19 | 
20 | namespace ucorf
21 | {
22 |     using boost_ec = ::boost::system::error_code;
23 | 
24 | } //namespace ucorf
25 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_message.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "message.h"
 5 | #include <memory>
 6 | 
 7 | namespace ucorf
 8 | {
 9 |     class Hprose_Message : public IMessage
10 |     {
11 |     public:
12 |         Hprose_Message() = default;
13 |         explicit Hprose_Message(std::string const& body);
14 | 
15 |         virtual bool Serialize(void* buf, std::size_t len);
16 |         virtual std::size_t ByteSize();
17 |         virtual std::size_t Parse(const void* buf, std::size_t len);
18 | 
19 |         std::string body_;
20 |     };
21 | } //namespace ucorf
22 | 


--------------------------------------------------------------------------------
/ucorf/url.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     class Url
 8 |     {
 9 |     public:
10 |         enum class eProto
11 |         {
12 |             tcp,
13 |             tls,
14 |             udp,
15 |             http,
16 |             https,
17 |             zookeeper,
18 |         };
19 | 
20 |         eProto proto_;
21 |         std::string ori_address_;
22 |         std::vector<std::pair<std::string, uint16_t>> address_;
23 |         std::string path_;
24 | 
25 |         explicit Url(std::string const& str);
26 |     };
27 | 
28 | } //namespace ucorf
29 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_message.cpp:
--------------------------------------------------------------------------------
 1 | #include "hprose_message.h"
 2 | 
 3 | namespace ucorf {
 4 | 
 5 | Hprose_Message::Hprose_Message(std::string const& body)
 6 |     : body_(body)
 7 | {
 8 | }
 9 | bool Hprose_Message::Serialize(void * buf, std::size_t len)
10 | {
11 |     if (len < ByteSize()) return false;
12 |     memcpy(buf, body_.data(), len);
13 |     return true;
14 | }
15 | std::size_t Hprose_Message::ByteSize()
16 | {
17 |     return body_.size();
18 | }
19 | std::size_t Hprose_Message::Parse(const void * buf, std::size_t len)
20 | {
21 |     body_.assign((const char*)buf, len);
22 |     return len;
23 | }
24 | 
25 | } //namespace ucorf
26 | 


--------------------------------------------------------------------------------
/ucorf/server_register.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     class IServerRegister
 8 |     {
 9 |     public:
10 |         virtual ~IServerRegister() {}
11 | 
12 |         virtual bool Register(std::string url, std::string srv_info) = 0;
13 | 
14 |         virtual void Unregister() = 0;
15 |     };
16 | 
17 |     class ZookeeperRegister : public IServerRegister
18 |     {
19 |     public:
20 |         virtual bool Register(std::string url, std::string srv_info);
21 | 
22 |         virtual void Unregister();
23 | 
24 |     private:
25 |         std::multimap<std::string, std::string> destinations_;
26 |     };
27 | 
28 | } //namespace ucorf
29 | 


--------------------------------------------------------------------------------
/ucorf/service.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "message.h"
 5 | 
 6 | namespace ucorf
 7 | {
 8 |     class IMessage;
 9 |     class IService
10 |     {
11 |     public:
12 |         virtual ~IService() {}
13 | 
14 |         virtual std::string name() = 0;
15 | 
16 |         virtual std::unique_ptr<IMessage> CallMethod(std::string const& method,
17 |                 const char *request_data, size_t request_bytes) = 0;
18 |     };
19 | 
20 |     class Client;
21 |     class IServiceStub
22 |     {
23 |     public:
24 |         explicit IServiceStub(Client * c) : c_(c) {}
25 | 
26 |         virtual ~IServiceStub() {}
27 | 
28 |         virtual std::string name() = 0;
29 | 
30 |     protected:
31 |         Client * c_;
32 |     };
33 | 
34 | } //namespace ucorf
35 | 


--------------------------------------------------------------------------------
/ucorf/pb_message.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "message.h"
 5 | #include <memory>
 6 | #include <google/protobuf/message.h>
 7 | 
 8 | namespace ucorf
 9 | {
10 |     class Pb_Message : public IMessage
11 |     {
12 |         Pb_Message(Pb_Message const&) = delete;
13 |         Pb_Message& operator=(Pb_Message const&) = delete;
14 | 
15 |     public:
16 |         Pb_Message() = default;
17 |         Pb_Message(::google::protobuf::Message* msg, bool own = true);
18 |         Pb_Message(std::unique_ptr<::google::protobuf::Message> && msg);
19 |         ~Pb_Message();
20 | 
21 |         virtual bool Serialize(void* buf, std::size_t len);
22 |         virtual std::size_t ByteSize();
23 |         virtual std::size_t Parse(const void* buf, std::size_t len);
24 |         
25 |         ::google::protobuf::Message* msg_ = nullptr;
26 |         bool own_ = false;
27 |     };
28 | } //namespace ucorf
29 | 


--------------------------------------------------------------------------------
/samples/sample1_server.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample1: 最简单的Server
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | 
 9 | // 1.继承代码生成器生成的类，并重写定义的rpc接口
10 | struct MyEcho : public ::Echo::UcorfEchoService
11 | {
12 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
13 |     {
14 |         // 处理请求
15 |         response.set_code(request.code());
16 |         return true;
17 |     }
18 | };
19 | 
20 | int main()
21 | {
22 |     // 2.创建server对象
23 |     ucorf::Server server;
24 | 
25 |     // 3.注册MyEcho服务
26 |     server.RegisterService(boost::shared_ptr<IService>(new MyEcho));
27 | 
28 |     // 4.启动监听端口
29 |     ucorf::boost_ec ec = server.Listen("tcp://127.0.0.1:8080");     // 监听本机8080端口
30 | 
31 |     // 5.启动协程框架主循环
32 |     co_sched.RunLoop();     
33 | 
34 |     return 0;
35 | }
36 | 
37 | 


--------------------------------------------------------------------------------
/samples/sample3_client.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample2: 从Zookeeper获取服务端地址的Client
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | 
 9 | int main(int argc, char **argv)
10 | {
11 |     // 1.创建Client对象
12 |     ucorf::Client client;
13 | 
14 |     // 2.设置服务端注册的ZK地址和节点, 格式如下：
15 |     client.SetUrl("zk://127.0.0.1:2181/ucorf/test");
16 | 
17 |     // 3.创建Stub对象，并绑定Client
18 |     UcorfEchoServiceStub stub(&client);
19 | 
20 |     // 4.启动一个协程
21 |     go [&]{
22 |         co_sleep(500);
23 | 
24 |         // 5.构造RPC调用参数
25 |         EchoRequest request;
26 |         request.set_code(1);
27 | 
28 |         // 6.调用RPC接口
29 |         std::shared_ptr<EchoResponse> rsp = stub.Echo(request);
30 | 
31 |         // 7.获取返回值
32 |         std::cout << "Response: " << rsp->code() << endl;
33 |     };
34 | 
35 |     // 8.启动协程框架主循环
36 |     co_sched.RunLoop();
37 |     return 0;
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/samples/sample2_server.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample2: 同时监听多个端口的Server
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | using namespace ucorf;
 9 | 
10 | // 1.继承代码生成器生成的类，并重写定义的rpc接口
11 | struct MyEcho : public ::Echo::UcorfEchoService
12 | {
13 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
14 |     {
15 |         // 处理请求
16 |         response.set_code(request.code());
17 |         return true;
18 |     }
19 | };
20 | 
21 | int main()
22 | {
23 |     // 2.创建server对象
24 |     ucorf::Server server;
25 | 
26 |     // 3.注册MyEcho服务
27 |     server.RegisterService(boost::shared_ptr<IService>(new MyEcho));
28 | 
29 |     // 4.监听2个端口
30 |     server.Listen("tcp://127.0.0.1:8080");     // 监听本机8080端口
31 |     server.Listen("tcp://127.0.0.1:8081");     // 监听本机8081端口
32 | 
33 |     // 5.启动协程框架主循环
34 |     co_sched.RunLoop();     
35 | 
36 |     return 0;
37 | }
38 | 
39 | 


--------------------------------------------------------------------------------
/ucorf/pb_message.cpp:
--------------------------------------------------------------------------------
 1 | #include "pb_message.h"
 2 | 
 3 | namespace ucorf
 4 | {
 5 |     Pb_Message::Pb_Message(::google::protobuf::Message* msg, bool own)
 6 |         : msg_(msg), own_(own)
 7 |     {
 8 |     }
 9 | 
10 |     Pb_Message::Pb_Message(std::unique_ptr<::google::protobuf::Message> && msg)
11 |         : msg_(msg.release()), own_(true)
12 |     {
13 |     }
14 | 
15 |     Pb_Message::~Pb_Message()
16 |     {
17 |         if (own_ && msg_)
18 |             delete msg_;
19 |     }
20 | 
21 |     bool Pb_Message::Serialize(void* buf, std::size_t len)
22 |     {
23 |         if (!msg_) return false;
24 |         return msg_->SerializeToArray(buf, len);
25 |     }
26 |     std::size_t Pb_Message::ByteSize()
27 |     {
28 |         if (!msg_) return 0;
29 |         return msg_->ByteSize();
30 |     }
31 |     std::size_t Pb_Message::Parse(const void* buf, std::size_t len)
32 |     {
33 |         if (!msg_) return 0;
34 |         return msg_->ParseFromArray(buf, len);
35 |     }
36 | 
37 | } //namespace ucorf
38 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_header.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "message.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     struct Hprose_Head : public IHeader
 8 |     {
 9 |     public:
10 |         virtual void SetId(std::size_t id);
11 |         virtual void SetFollowBytes(std::size_t bytes);
12 | 
13 |         virtual void SetType(eHeaderType) {}
14 |         virtual void SetService(std::string const&) {}
15 |         virtual void SetMethod(std::string const&) {}
16 | 
17 |         virtual std::size_t GetId();
18 |         virtual eHeaderType GetType();
19 |         virtual std::size_t GetFollowBytes();
20 |         virtual std::string GetService();
21 |         virtual std::string GetMethod() { return ""; }
22 | 
23 |         virtual bool Serialize(void* buf, std::size_t len);
24 |         virtual std::size_t ByteSize();
25 |         virtual std::size_t Parse(const void* buf, std::size_t len);
26 | 
27 |         static IHeaderPtr Factory();
28 | 
29 |         uint32_t callid;
30 |         uint32_t body_length;
31 |     };
32 | } //namespace ucorf
33 | 


--------------------------------------------------------------------------------
/ucorf/error.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <boost/system/error_code.hpp>
 3 | #include <boost/system/system_error.hpp>
 4 | #include <string>
 5 | 
 6 | namespace ucorf
 7 | {
 8 | 
 9 |     using boost_ec = boost::system::error_code;
10 | 
11 |     enum class eUcorfErrorCode : int
12 |     {
13 |         ec_ok           = 0,
14 |         ec_snd_timeout  = 1,
15 |         ec_rcv_timeout  = 2,
16 |         ec_call_error   = 3,
17 |         ec_parse_error  = 4,
18 |         ec_no_estab     = 5,
19 |         ec_unsupport_protocol   = 6,
20 |         ec_req_wnd_full = 7,
21 |         ec_logic_error  = 8,
22 |     };
23 | 
24 |     class ucorf_error_category
25 |         : public boost::system::error_category
26 |     {
27 |     public:
28 |         virtual const char* name() const BOOST_SYSTEM_NOEXCEPT;
29 | 
30 |         virtual std::string message(int) const;
31 |     };
32 | 
33 |     const boost::system::error_category& GetUcorfErrorCategory();
34 | 
35 |     boost_ec MakeUcorfErrorCode(eUcorfErrorCode code);
36 | 
37 |     void ThrowError(eUcorfErrorCode code, const char* what = "");
38 | 
39 | } //namespace ucorf
40 | 


--------------------------------------------------------------------------------
/ucorf/server.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "server_impl.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     class Server
 8 |     {
 9 |     public:
10 |         typedef boost::function<IMessage*(std::string const&, std::string const&)> MessageFactory;
11 | 
12 |         Server();
13 | 
14 |         Server& SetOption(boost::shared_ptr<Option> opt);
15 | 
16 |         bool RegisterTo(std::string const& url);
17 | 
18 |         bool RegisterService(boost::shared_ptr<IService> service);
19 | 
20 |         void RemoveService(std::string const& service_name);
21 | 
22 |         boost_ec Listen(std::string const& url);
23 | 
24 |         /// --------------------------- extend method ---------------------------
25 |     public:
26 |         Server& BindTransport(std::unique_ptr<ITransportServer> && transport);
27 |         Server& SetHeaderFactory(HeaderFactory const& head_factory);
28 |         Server& SetRegister(boost::shared_ptr<IServerRegister> reg);
29 |         /// ---------------------------------------------------------------------
30 | 
31 |     private:
32 |         boost::shared_ptr<ServerImpl> impl_;
33 |     };
34 | 
35 | } //namespace ucorf
36 | 


--------------------------------------------------------------------------------
/samples/sample1_client.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample1: 最简单的Client
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | 
 9 | int main(int argc, char **argv)
10 | {
11 |     // 1.创建Client对象
12 |     ucorf::Client client;
13 | 
14 |     // 2.设置服务端地址
15 |     client.SetUrl("tcp://127.0.0.1:8080");
16 | 
17 |     // 3.创建Stub对象，并绑定Client
18 |     UcorfEchoServiceStub stub(&client);
19 | 
20 |     // 4.启动一个协程
21 |     go [&]{
22 |         // 为了分布式部署时不存在依赖性，client在后台自动尝试连接服务端、断线重连
23 |         // 所以写demo测试时, 要等待客户端连上以后再调用
24 |         // 实际在服务中由于时用户触发的行为，所以不必如此
25 |         // 和很多框架一样，client的连接尝试是在主循环中开始的, 因此要在协程中sleep
26 |         co_sleep(500);
27 | 
28 |         // 5.构造RPC调用参数
29 |         EchoRequest request;
30 |         request.set_code(1);
31 | 
32 |         // 6.调用RPC接口
33 |         std::shared_ptr<EchoResponse> rsp = stub.Echo(request);
34 | 
35 |         // 7.获取返回值
36 |         std::cout << "Response: " << rsp->code() << endl;
37 |     };
38 | 
39 |     // 8.启动协程框架主循环
40 |     co_sched.RunLoop();
41 |     return 0;
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/ucorf/client.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "client_impl.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     class Client
 8 |     {
 9 |     public:
10 |         typedef boost::function<ITransportClient*()> TransportFactory;
11 | 
12 |         Client();
13 | 
14 |         Client& SetOption(boost::shared_ptr<Option> opt);
15 | 
16 |         Client& SetUrl(std::string const& url);
17 | 
18 |         boost_ec Call(std::string const& service_name,
19 |                 std::string const& method_name,
20 |                 IMessage *request, IMessage *response);
21 | 
22 |         /// ------------------------ extend method --------------------------
23 |     public:
24 |         Client& SetDispatcher(std::unique_ptr<IDispatcher> && dispatcher);
25 |         Client& SetHeaderFactory(HeaderFactory const& head_factory);
26 |         Client& SetServerFinder(std::unique_ptr<ServerFinder> && srv_finder);
27 |         Client& SetTransportFactory(TransportFactory const& factory);
28 |         /// -----------------------------------------------------------------
29 |         
30 |     private:
31 |         boost::shared_ptr<ClientImpl> impl_;
32 |     };
33 | 
34 | } //namespace ucorf
35 | 


--------------------------------------------------------------------------------
/test/hprose_client.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/client.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include <ucorf/dispatcher.h>
 4 | #include <ucorf/server_finder.h>
 5 | #include <ucorf/hprose/hprose_service.h>
 6 | #include "echo.rpc.h"
 7 | #include <iostream>
 8 | #include <boost/smart_ptr/make_shared.hpp>
 9 | using std::cout;
10 | using std::endl;
11 | 
12 | int main(int argc, char **argv)
13 | {
14 |     using namespace ucorf;
15 |     using namespace ucorf::hprose;
16 | 
17 |     const char* url = "tcp://127.0.0.1:48080";
18 |     if (argc > 1)
19 |         url = argv[1];
20 | 
21 |     Client client;
22 |     client.SetUrl(url);
23 |     client.SetHeaderFactory(&Hprose_Head::Factory);
24 |     Hprose_ServiceStub stub(&client);
25 | 
26 |     go [&]{
27 | retry:
28 |         boost_ec ec;
29 |         int rsp = stub.CallMethod<int>("add", ec, 1);
30 |         if (ec) {
31 |             cout << "rpc call error: " << ec.message() << endl;
32 |         } else {
33 |             cout << "rpc call success, response=" << rsp << endl;
34 |         }
35 | 
36 |         co_sleep(1000);
37 |         goto retry;
38 |     };
39 | 
40 |     co_sched.RunLoop();
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/test/server.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/server.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include "echo.rpc.h"
 4 | #include <iostream>
 5 | #include <boost/smart_ptr/make_shared.hpp>
 6 | using std::cout;
 7 | using std::endl;
 8 | using namespace Echo;
 9 | 
10 | struct MyEcho : public ::Echo::UcorfEchoService
11 | {
12 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
13 |     {
14 |         cout << "Handle Echo, code=" << request.code() << endl;
15 |         response.set_code(request.code());
16 |         return true;
17 |     }
18 | };
19 | 
20 | int main(int argc, char **argv)
21 | {
22 |     using namespace ucorf;
23 | 
24 |     const char* url = "tcp://127.0.0.1:48080";
25 |     if (argc > 1)
26 |         url = argv[1];
27 | 
28 |     boost::shared_ptr<IService> echo_srv(new MyEcho);
29 |     Server server;
30 |     server.RegisterService(echo_srv);
31 |     boost_ec ec = server.Listen(url);
32 |     if (ec) {
33 |         cout << "listen " << url << " error: " << ec.message() << endl;
34 |         return 1;
35 |     } else {
36 |         cout << "start success: " << url << endl;
37 |     }
38 | 
39 |     co_sched.RunLoop();
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/samples/sample3_server.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample3: 注册到zookeeper的Server
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | using namespace ucorf;
 9 | 
10 | // 1.继承代码生成器生成的类，并重写定义的rpc接口
11 | struct MyEcho : public ::Echo::UcorfEchoService
12 | {
13 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
14 |     {
15 |         // 处理请求
16 |         response.set_code(request.code());
17 |         return true;
18 |     }
19 | };
20 | 
21 | int main()
22 | {
23 |     // 2.创建server对象
24 |     ucorf::Server server;
25 | 
26 |     // 3.注册MyEcho服务
27 |     server.RegisterService(boost::shared_ptr<IService>(new MyEcho));
28 | 
29 |     // 4.监听端口
30 |     server.Listen("tcp://127.0.0.1:8080");     // 监听本机8080端口
31 |     server.Listen("udp://127.0.0.1:8080");     // 也可以监听UDP端口
32 | 
33 |     // 5.注册到Zookeeper
34 |     server.RegisterTo("zk://127.0.0.1:2181/ucorf/test");
35 |     server.RegisterTo("zk://127.0.0.1:2181/ucorf/test2"); // 可以同时注册到不同ZK的多个节点上
36 | 
37 |     // 6.启动协程框架主循环
38 |     co_sched.RunLoop();     
39 | 
40 |     return 0;
41 | }
42 | 
43 | 


--------------------------------------------------------------------------------
/test/hprose_server.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/server.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include <ucorf/hprose/hprose_service.h>
 4 | #include <iostream>
 5 | #include <boost/smart_ptr/make_shared.hpp>
 6 | using std::cout;
 7 | using std::endl;
 8 | 
 9 | int add(int v)
10 | {
11 |     cout << "call add, value=" << v << endl;
12 |     return v + v;
13 | }
14 | 
15 | int main(int argc, char **argv)
16 | {
17 |     using namespace ucorf;
18 |     using namespace ucorf::hprose;
19 | 
20 |     const char* url = "tcp://127.0.0.1:48080";
21 |     if (argc > 1)
22 |         url = argv[1];
23 | 
24 |     Hprose_Service *hp_srv = new Hprose_Service;
25 |     hp_srv->RegisterFunction("add", boost::function<int(int)>(&add));
26 |     boost::shared_ptr<IService> srv(hp_srv);
27 |     Server server;
28 |     server.SetHeaderFactory(&Hprose_Head::Factory);
29 |     server.RegisterService(srv);
30 |     boost_ec ec = server.Listen(url);
31 |     if (ec) {
32 |         cout << "listen " << url << " error: " << ec.message() << endl;
33 |         return 1;
34 |     } else {
35 |         cout << "start success: " << url << endl;
36 |     }
37 | 
38 |     co_sched.RunLoop();
39 |     return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/ucorf/pb_service.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "service.h"
 4 | #include "pb_message.h"
 5 | #include <google/protobuf/descriptor.h>
 6 | #include <google/protobuf/message.h>
 7 | 
 8 | namespace ucorf
 9 | {
10 |     using namespace ::google::protobuf;
11 | 
12 |     class Pb_Service : public IService
13 |     {
14 |     public:
15 |         virtual std::string name() = 0;
16 | 
17 |         std::unique_ptr<IMessage> CallMethod(std::string const& method,
18 |                 const char *request_data, size_t request_bytes) override;
19 | 
20 |         virtual bool Call(int method_idx, Message & request, Message & response) = 0;
21 | 
22 |         virtual const ServiceDescriptor* GetDescriptor() = 0;
23 | 
24 |         const Message& GetRequestPrototype(
25 |                 const MethodDescriptor* method) const;
26 |         const Message& GetResponsePrototype(
27 |                 const MethodDescriptor* method) const;
28 |     };
29 | 
30 |     class Pb_ServiceStub : public IServiceStub
31 |     {
32 |     public:
33 |         using IServiceStub::IServiceStub;
34 | 
35 |         boost_ec CallMethod(std::string const& method,
36 |                 Message & request, Message * response);
37 |     };
38 | 
39 | } //namespace ucorf
40 | 


--------------------------------------------------------------------------------
/test/zk_client.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/client.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include <ucorf/dispatcher.h>
 4 | #include <ucorf/server_finder.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | #include <boost/smart_ptr/make_shared.hpp>
 8 | using std::cout;
 9 | using std::endl;
10 | using namespace Echo;
11 | 
12 | int main(int argc, char **argv)
13 | {
14 |     using namespace ucorf;
15 | 
16 |     const char* url = "zk://127.0.0.1:2181/ucorf/test";
17 |     if (argc > 1)
18 |         url = argv[1];
19 | 
20 |     std::unique_ptr<HashDispatcher> dispatcher(new HashDispatcher);
21 |     Client client;
22 |     client.SetDispatcher(std::move(dispatcher)).SetUrl(url);
23 |     UcorfEchoServiceStub stub(&client);
24 | 
25 |     go [&]{
26 | retry:
27 |         EchoRequest request;
28 |         request.set_code(1);
29 | 
30 |         boost_ec ec;
31 |         std::shared_ptr<EchoResponse> rsp = stub.Echo(request, &ec);
32 |         if (ec) {
33 |             cout << "rpc call error: " << ec.message() << endl;
34 |         } else {
35 |             cout << "rpc call success, response.code=" << rsp->code() << endl;
36 |         }
37 | 
38 |         co_sleep(1000);
39 |         goto retry;
40 |     };
41 | 
42 |     co_sched.RunLoop();
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_header.cpp:
--------------------------------------------------------------------------------
 1 | #include "hprose_header.h"
 2 | 
 3 | namespace ucorf {
 4 | 
 5 | void Hprose_Head::SetId(std::size_t id)
 6 | {
 7 |     callid = id;
 8 | }
 9 | void Hprose_Head::SetFollowBytes(std::size_t bytes)
10 | {
11 |     body_length = bytes;
12 | }
13 | std::size_t Hprose_Head::GetId()
14 | {
15 |     return callid;
16 | }
17 | eHeaderType Hprose_Head::GetType()
18 | {
19 |     return eHeaderType::request;
20 | }
21 | std::size_t Hprose_Head::GetFollowBytes()
22 | {
23 |     return body_length;
24 | }
25 | std::string Hprose_Head::GetService()
26 | {
27 |     return "hprose";
28 | }
29 | bool Hprose_Head::Serialize(void * buf, std::size_t len)
30 | {
31 |     if (len < 8) return false;
32 |     *(uint32_t*)((char*)buf) = htonl(body_length);
33 |     *(uint32_t*)((char*)buf + 4) = htonl(callid);
34 |     return true;
35 | }
36 | std::size_t Hprose_Head::Parse(const void* buf, std::size_t len)
37 | {
38 |     if (len < 8) return 0;
39 |     body_length = htonl(*(uint32_t*)((char*)buf));
40 |     callid = htonl(*(uint32_t*)((char*)buf + 4));
41 |     return 8;
42 | }
43 | std::size_t Hprose_Head::ByteSize()
44 | {
45 |     return 8;
46 | }
47 | IHeaderPtr Hprose_Head::Factory()
48 | {
49 |     return boost::static_pointer_cast<IHeader>(boost::make_shared<Hprose_Head>());
50 | }
51 | 
52 | } //namespace ucorf
53 | 


--------------------------------------------------------------------------------
/samples/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | project(test)
 3 | set(CMAKE_CXX_FLAGS "-std=c++11 -g")
 4 | set(CMAKE_CXX_FLAGS_RELEASE "-std=c++11 -O3")
 5 | include_directories("${PROJECT_SOURCE_DIR}/../test")
 6 | set(PROTO_LIST ${PROJECT_SOURCE_DIR}/../test/echo.pb.cc ${PROJECT_SOURCE_DIR}/../test/echo.rpc.cc)
 7 | set(LINK_ARGS "-lucorf -lnetwork -lcoroutine -lprotobuf -lboost_thread -lboost_system -lboost_regex -lzookeeper_mt -ldl -lpthread")
 8 | 
 9 | add_executable(sample1_server.t sample1_server.cpp ${PROTO_LIST})
10 | target_link_libraries(sample1_server.t ${LINK_ARGS})
11 | add_executable(sample1_client.t sample1_client.cpp ${PROTO_LIST})
12 | target_link_libraries(sample1_client.t ${LINK_ARGS})
13 | 
14 | add_executable(sample2_server.t sample2_server.cpp ${PROTO_LIST})
15 | target_link_libraries(sample2_server.t ${LINK_ARGS})
16 | add_executable(sample2_client.t sample2_client.cpp ${PROTO_LIST})
17 | target_link_libraries(sample2_client.t ${LINK_ARGS})
18 | 
19 | add_executable(sample3_server.t sample3_server.cpp ${PROTO_LIST})
20 | target_link_libraries(sample3_server.t ${LINK_ARGS})
21 | add_executable(sample3_client.t sample3_client.cpp ${PROTO_LIST})
22 | target_link_libraries(sample3_client.t ${LINK_ARGS})
23 | 
24 | add_executable(sample4_client.t sample4_client.cpp ${PROTO_LIST})
25 | target_link_libraries(sample4_client.t ${LINK_ARGS})
26 | 


--------------------------------------------------------------------------------
/ucorf/server.cpp:
--------------------------------------------------------------------------------
 1 | #include "server.h"
 2 | 
 3 | namespace ucorf
 4 | {
 5 |     Server::Server()
 6 |         : impl_(new ServerImpl)
 7 |     {}
 8 | 
 9 |     Server& Server::SetOption(boost::shared_ptr<Option> opt)
10 |     {
11 |         impl_->SetOption(opt);
12 |         return *this;
13 |     }
14 | 
15 |     bool Server::RegisterTo(std::string const& url)
16 |     {
17 |         return impl_->RegisterTo(url);
18 |     }
19 | 
20 |     bool Server::RegisterService(boost::shared_ptr<IService> service)
21 |     {
22 |         return impl_->RegisterService(service);
23 |     }
24 | 
25 |     void Server::RemoveService(std::string const& service_name)
26 |     {
27 |         impl_->RemoveService(service_name);
28 |     }
29 | 
30 |     boost_ec Server::Listen(std::string const& url)
31 |     {
32 |         return impl_->Listen(url);
33 |     }
34 | 
35 |     Server& Server::BindTransport(std::unique_ptr<ITransportServer> && transport)
36 |     {
37 |         impl_->BindTransport(std::move(transport));
38 |         return *this;
39 |     }
40 |     Server& Server::SetHeaderFactory(HeaderFactory const& head_factory)
41 |     {
42 |         impl_->SetHeaderFactory(head_factory);
43 |         return *this;
44 |     }
45 |     Server& Server::SetRegister(boost::shared_ptr<IServerRegister> reg)
46 |     {
47 |         impl_->SetRegister(reg);
48 |         return *this;
49 |     }
50 | 
51 | } //namespace ucorf
52 | 


--------------------------------------------------------------------------------
/samples/sample2_client.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample2: 对一个服务端建立多条连接的客户端
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | using namespace ucorf;
 9 | 
10 | int main(int argc, char **argv)
11 | {
12 |     // 1.创建Client对象
13 |     ucorf::Client client;
14 | 
15 |     // 2.创建多条连接
16 |     for (int i = 0; i < 10; ++i)
17 |         client.SetServerFinder(std::unique_ptr<ServerFinder>(new ServerFinder));
18 | 
19 |     // 3.设置服务端地址
20 |     client.SetUrl("tcp://127.0.0.1:8080");
21 | 
22 |     // 4.创建Stub对象，并绑定Client
23 |     UcorfEchoServiceStub stub(&client);
24 | 
25 |     /* 5.启动多个协程 */ 
26 |     for (int i = 0; i < 10; ++i)
27 |         go [&]{
28 |             co_sleep(1000);
29 | 
30 |             // 6.构造RPC调用参数
31 |             EchoRequest request;
32 |             request.set_code(1);
33 | 
34 |             // 7.调用RPC接口
35 |             boost_ec ec;
36 |             std::shared_ptr<EchoResponse> rsp = stub.Echo(request, &ec);
37 | 
38 |             if (ec) {
39 |                 // 调用失败
40 |                 std::cout << "call error:" << ec.message() << std::endl;
41 |             } else {
42 |                 // 8.获取返回值
43 |                 std::cout << "Response: " << rsp->code() << endl;
44 |             }
45 |         };
46 | 
47 |     // 6.修改Log输出目的地
48 |     ucorf::Logger::default_instance().Reopen("/dev/null");
49 | 
50 |     // 7.启动协程框架主循环
51 |     co_sched.RunLoop();
52 |     return 0;
53 | }
54 | 
55 | 


--------------------------------------------------------------------------------
/ucorf/server_register.cpp:
--------------------------------------------------------------------------------
 1 | #include "server_register.h"
 2 | #include <boost/algorithm/string.hpp>
 3 | #include "logger.h"
 4 | #include "zookeeper.h"
 5 | #include <boost/regex.hpp>
 6 | 
 7 | namespace ucorf
 8 | {
 9 |     bool ZookeeperRegister::Register(std::string url, std::string srv_info)
10 |     {
11 |         auto addr_path = ZookeeperClientMgr::getInstance().ParseZookeeperUrl(url);
12 |         if (addr_path.first.empty()) return false;
13 | 
14 |         std::string addr = addr_path.first;
15 |         std::string path = addr_path.second;
16 |         std::string zk_node = ZookeeperClientMgr::getInstance().Url2ZookeeperNode(srv_info);
17 |         if (zk_node.empty()) {
18 |             ucorf_log_error("convert srv_info(%s) to zookeeper node error", srv_info.c_str());
19 |             return false;
20 |         }
21 |         path += "/" + zk_node;
22 | 
23 |         auto zk = ZookeeperClientMgr::getInstance().GetZookeeperClient(addr);
24 |         if (!zk->DelayCreateEphemeralNode(path)) {
25 |             ucorf_log_error("create node(%s) to zookeeper(%s) error.", path.c_str(), addr.c_str());
26 |             return false;
27 |         }
28 | 
29 |         destinations_.insert(std::make_pair(addr, path));
30 |         return true;
31 |     }
32 | 
33 |     void ZookeeperRegister::Unregister()
34 |     {
35 |         for (auto &kv : destinations_) {
36 |             auto zk = ZookeeperClientMgr::getInstance().GetZookeeperClient(kv.first);
37 |             zk->DeleteNode(kv.second);
38 |         }
39 |     }
40 | 
41 | } //namespace ucorf
42 | 


--------------------------------------------------------------------------------
/ucorf/client.cpp:
--------------------------------------------------------------------------------
 1 | #include "client.h"
 2 | 
 3 | namespace ucorf
 4 | {
 5 |     Client::Client()
 6 |         : impl_(new ClientImpl)
 7 |     {}
 8 | 
 9 |     Client& Client::SetOption(boost::shared_ptr<Option> opt)
10 |     {
11 |         impl_->SetOption(opt);
12 |         return *this;
13 |     }
14 | 
15 |     Client& Client::SetUrl(std::string const& url)
16 |     {
17 |         impl_->SetUrl(url);
18 |         return *this;
19 |     }
20 | 
21 |     boost_ec Client::Call(std::string const& service_name,
22 |             std::string const& method_name,
23 |             IMessage *request, IMessage *response)
24 |     {
25 |         return impl_->Call(service_name, method_name, request, response);
26 |     }
27 | 
28 |     /// ------------------------ extend method --------------------------
29 |     Client& Client::SetDispatcher(std::unique_ptr<IDispatcher> && dispatcher)
30 |     {
31 |         impl_->SetDispatcher(std::move(dispatcher));
32 |         return *this;
33 |     }
34 |     Client& Client::SetHeaderFactory(HeaderFactory const& head_factory)
35 |     {
36 |         impl_->SetHeaderFactory(head_factory);
37 |         return *this;
38 |     }
39 |     Client& Client::SetServerFinder(std::unique_ptr<ServerFinder> && srv_finder)
40 |     {
41 |         impl_->SetServerFinder(std::move(srv_finder));
42 |         return *this;
43 |     }
44 |     Client& Client::SetTransportFactory(TransportFactory const& factory)
45 |     {
46 |         impl_->SetTransportFactory(factory);
47 |         return *this;
48 |     }
49 | 
50 | } //namespace ucorf
51 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(test)
 4 | if (CMAKE_BUILD_TYPE)
 5 | else()
 6 |     set(CMAKE_BUILD_TYPE RELEASE)
 7 | endif()
 8 | 
 9 | message("CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
10 | 
11 | include_directories("${PROJECT_SOURCE_DIR}/..")
12 | include_directories("${PROJECT_SOURCE_DIR}/../ucorf")
13 | include_directories("${PROJECT_SOURCE_DIR}/../ucorf/hprose")
14 | link_directories("${PROJECT_SOURCE_DIR}/../build")
15 | link_directories("${PROJECT_SOURCE_DIR}/../build/third_party/libgonet")
16 | link_directories("${PROJECT_SOURCE_DIR}/../build/third_party/libgonet/third_party/libgo")
17 | 
18 | set(CMAKE_CXX_FLAGS "-std=c++11")
19 | set(CMAKE_CXX_FLAGS_PROFILE "-g -pg -O3 ${CMAKE_CXX_FLAGS}")
20 | set(LINK_ARGS "-lucorf -llibgonet -llibgo -lprotobuf -lboost_thread -lboost_system -lboost_coroutine -lboost_context -lboost_regex -lboost_thread -lzookeeper_mt -ldl -lpthread -static -static-libgcc -static-libstdc++")
21 | 
22 | aux_source_directory("${PROJECT_SOURCE_DIR}" SRC_LIST)
23 | 
24 | foreach(var ${SRC_LIST})
25 |     string(FIND "${var}" ".cpp" is_cpp)
26 |     if (${is_cpp} EQUAL -1)
27 |     else()
28 |         string(REGEX REPLACE ".*/" "" var ${var})
29 |         string(REGEX REPLACE ".cpp" "" tgt ${var})
30 | 
31 |         string(FIND "${var}" "hprose" is_hprose)
32 |         if (${is_hprose} EQUAL -1)
33 |             add_executable(${tgt}.t ${var} echo.rpc.cc echo.pb.cc)
34 |         else()
35 |             add_executable(${tgt}.t ${var})
36 |         endif()
37 |         target_link_libraries(${tgt}.t ${LINK_ARGS})
38 |     endif()
39 | endforeach(var)
40 | 


--------------------------------------------------------------------------------
/test/client.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/client.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include <ucorf/dispatcher.h>
 4 | #include <ucorf/server_finder.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | #include <boost/smart_ptr/make_shared.hpp>
 8 | using std::cout;
 9 | using std::endl;
10 | using namespace Echo;
11 | 
12 | int main(int argc, char **argv)
13 | {
14 |     using namespace ucorf;
15 | 
16 |     const char* url = "tcp://127.0.0.1:48080";
17 |     if (argc > 1)
18 |         url = argv[1];
19 | 
20 |     Client client;
21 |     client.SetUrl(url);
22 |     UcorfEchoServiceStub stub(&client);
23 | 
24 | //    go [&]{
25 | //retry:
26 | //        EchoRequest request;
27 | //        request.set_code(1);
28 | //        EchoResponse response;
29 | //
30 | //        boost_ec ec = stub.Echo(request, &response);
31 | //        if (ec) {
32 | //            cout << "rpc call error: " << ec.message() << endl;
33 | //        } else {
34 | //            cout << "rpc call success, response.code=" << response.code() << endl;
35 | //        }
36 | //
37 | //        co_sleep(1000);
38 | //        goto retry;
39 | //    };
40 | 
41 |     go [&]{
42 | retry:
43 |         EchoRequest request;
44 |         request.set_code(1);
45 | 
46 |         boost_ec ec;
47 |         std::shared_ptr<EchoResponse> rsp = stub.Echo(request, &ec);
48 |         if (ec) {
49 |             cout << "rpc call error: " << ec.message() << endl;
50 |         } else {
51 |             cout << "rpc call success, response.code=" << rsp->code() << endl;
52 |         }
53 | 
54 |         co_sleep(1000);
55 |         goto retry;
56 |     };
57 | 
58 |     co_sched.RunLoop();
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/ucorf/error.cpp:
--------------------------------------------------------------------------------
 1 | #include "error.h"
 2 | 
 3 | namespace ucorf
 4 | {
 5 | 
 6 | const char* ucorf_error_category::name() const BOOST_SYSTEM_NOEXCEPT
 7 | {
 8 |     return "ucorf_error";
 9 | }
10 | 
11 | std::string ucorf_error_category::message(int v) const
12 | {
13 |     switch (v) {
14 |         case (int)eUcorfErrorCode::ec_ok:
15 |             return "ok";
16 | 
17 |         case (int)eUcorfErrorCode::ec_snd_timeout:
18 |             return "send timeout";
19 | 
20 |         case (int)eUcorfErrorCode::ec_rcv_timeout:
21 |             return "receive timeout";
22 | 
23 |         case (int)eUcorfErrorCode::ec_call_error:
24 |             return "call error";
25 | 
26 |         case (int)eUcorfErrorCode::ec_parse_error:
27 |             return "parse error";
28 | 
29 |         case (int)eUcorfErrorCode::ec_no_estab:
30 |             return "not estab";
31 | 
32 |         case (int)eUcorfErrorCode::ec_unsupport_protocol:
33 |             return "unsupport protocol";
34 | 
35 |         case (int)eUcorfErrorCode::ec_req_wnd_full:
36 |             return "request window was full";
37 | 
38 |         case (int)eUcorfErrorCode::ec_logic_error:
39 |             return "logic error";
40 |     }
41 | 
42 |     return "";
43 | }
44 | 
45 | const boost::system::error_category& GetUcorfErrorCategory()
46 | {
47 |     static ucorf_error_category obj;
48 |     return obj;
49 | }
50 | boost_ec MakeUcorfErrorCode(eUcorfErrorCode code)
51 | {
52 |     return boost_ec((int)code, GetUcorfErrorCategory());
53 | }
54 | void ThrowError(eUcorfErrorCode code, const char* what)
55 | {
56 |     if (std::uncaught_exception()) return ;
57 |     throw boost::system::system_error(MakeUcorfErrorCode(code), what);
58 | }
59 | 
60 | } //namespace ucorf
61 | 


--------------------------------------------------------------------------------
/test/zk_server.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/server.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include "echo.rpc.h"
 4 | #include <iostream>
 5 | #include <boost/smart_ptr/make_shared.hpp>
 6 | using std::cout;
 7 | using std::endl;
 8 | using namespace Echo;
 9 | 
10 | struct MyEcho : public ::Echo::UcorfEchoService
11 | {
12 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
13 |     {
14 |         cout << "Handle Echo, code=" << request.code() << endl;
15 |         response.set_code(request.code());
16 |         return true;
17 |     }
18 | };
19 | 
20 | int main(int argc, char **argv)
21 | {
22 |     using namespace ucorf;
23 | 
24 |     if (argc > 1 && std::string(argv[1]) == "-h" && std::string(argv[1]) == "--help") {
25 |         printf("Usage %s [listen_url] [zookeeper_url]\n", argv[0]);
26 |         exit(1);
27 |     }
28 | 
29 |     const char* url = "tcp://127.0.0.1:48080";
30 |     if (argc > 1)
31 |         url = argv[1];
32 | 
33 |     const char* zk_url = "zk://127.0.0.1:2181/ucorf/test";
34 |     if (argc > 2)
35 |         zk_url = argv[2];
36 | 
37 |     boost::shared_ptr<IService> echo_srv(new MyEcho);
38 |     Server server;
39 |     server.RegisterService(echo_srv);
40 |     boost_ec ec = server.Listen(url);
41 |     if (ec) {
42 |         cout << "listen " << url << " error: " << ec.message() << endl;
43 |         return 1;
44 |     } else {
45 |         cout << "start success: " << url << endl;
46 |     }
47 | 
48 |     if (!server.RegisterTo(zk_url)) {
49 |         cout << "register to zookeeper(" << zk_url << ") error." << endl;
50 |     } else {
51 |         cout << "register to zookeeper(" << zk_url << ") success." << endl;
52 |     }
53 | 
54 |     co_sched.RunLoop();
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/ucorf/transport.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     typedef boost::any SessId;
 8 | 
 9 |     class ITransport
10 |     {
11 |     public:
12 |         typedef boost::function<size_t(SessId, const char* data, size_t bytes)> OnReceiveF;
13 |         typedef boost::function<void(boost_ec const&)> OnSndF;
14 |         typedef boost::function<void(SessId)> OnConnectedF;
15 |         typedef boost::function<void(SessId, boost_ec const&)> OnDisconnectedF;
16 | 
17 |         virtual ~ITransport() {}
18 | 
19 |         virtual void Shutdown() = 0;
20 |         virtual void SetReceiveCb(OnReceiveF const&) = 0;
21 |         virtual void SetConnectedCb(OnConnectedF const&) {}
22 |         virtual void SetDisconnectedCb(OnDisconnectedF const&) {}
23 |         virtual void SetOption(boost::any const& opt) {}
24 |     };
25 | 
26 |     class ITransportServer : public ITransport
27 |     {
28 |     public:
29 |         virtual boost_ec Listen(std::string const& url) = 0;
30 |         virtual void Send(SessId id, const void* data, size_t bytes, OnSndF const& cb = NULL) = 0;
31 |         virtual void Send(SessId id, std::vector<char> && buf, OnSndF const& cb = NULL) = 0;
32 |         virtual std::string LocalUrl() const = 0;
33 |     };
34 | 
35 |     class ITransportClient : public ITransport
36 |     {
37 |     public:
38 |         virtual boost_ec Connect(std::string const& url) = 0;
39 |         virtual void Send(const void* data, size_t bytes, OnSndF const& cb = NULL) = 0;
40 |         virtual void Send(std::vector<char> && buf, OnSndF const& cb = NULL) = 0;
41 |         virtual bool IsEstab() = 0;
42 |         virtual std::string RemoteUrl() const = 0;
43 |     };
44 | 
45 | } //namespace ucorf
46 | 


--------------------------------------------------------------------------------
/ucorf/pb_service.cpp:
--------------------------------------------------------------------------------
 1 | #include "pb_service.h"
 2 | #include "client.h"
 3 | 
 4 | namespace ucorf
 5 | {
 6 |     std::unique_ptr<IMessage> Pb_Service::CallMethod(std::string const& method,
 7 |             const char *request_data, size_t request_bytes)
 8 |     {
 9 |         const MethodDescriptor* method_descriptor =
10 |             GetDescriptor()->FindMethodByName(method);
11 | 
12 |         if (!method_descriptor) return nullptr;
13 | 
14 |         std::unique_ptr<Message> request(GetRequestPrototype(method_descriptor).New());
15 |         if (!request->ParseFromArray(request_data, request_bytes))
16 |             return nullptr;
17 | 
18 |         std::unique_ptr<Message> response(GetResponsePrototype(method_descriptor).New());
19 | 
20 |         bool ok = Call(method_descriptor->index(), *request, *response);
21 |         if (!ok) return nullptr;
22 | 
23 |         std::unique_ptr<IMessage> rsp_msg(new Pb_Message(std::move(response)));
24 |         return std::move(rsp_msg);
25 |     }
26 | 
27 |     const Message& Pb_Service::GetRequestPrototype(
28 |             const MethodDescriptor* method) const
29 |     {
30 |         return *MessageFactory::generated_factory()->GetPrototype(method->input_type());
31 |     }
32 |     const Message& Pb_Service::GetResponsePrototype(
33 |             const MethodDescriptor* method) const
34 |     {
35 |         return *MessageFactory::generated_factory()->GetPrototype(method->output_type());
36 |     }
37 | 
38 |     boost_ec Pb_ServiceStub::CallMethod(std::string const& method,
39 |             Message & request, Message * response)
40 |     {
41 |         Pb_Message req(&request, false);
42 |         Pb_Message rsp(response, false);
43 |         return c_->Call(name(), method, &req, response ? &rsp : (Pb_Message*)nullptr);
44 |     }
45 | 
46 | } //namespace ucorf
47 | 


--------------------------------------------------------------------------------
/samples/sample4_client.cpp:
--------------------------------------------------------------------------------
 1 | /********************************
 2 |  * Sample2: 使用一致性HASH算法负载均衡的Client
 3 | *********************************/
 4 | #include <ucorf/ucorf.h>
 5 | #include "echo.rpc.h"
 6 | #include <iostream>
 7 | using namespace Echo;
 8 | 
 9 | int main(int argc, char **argv)
10 | {
11 |     // 1.创建Client对象
12 |     ucorf::Client client;
13 | 
14 |     // 2.设置一致性HASH的dispatcher
15 |     ucorf::HashDispatcher *dispatcher(new ucorf::HashDispatcher);
16 | 
17 |     /// (可选)设置Hash函数 
18 |     dispatcher->SetHashFunction([](std::string const& service_name,
19 |                 std::string const& method_name, IMessage *request) -> std::size_t
20 |             {
21 |                 // 根据code做hash, 可以把同样code的请求发到同一个server
22 |                 // 注意：整数不要直接使用std::hash处理，得到的hash值不够离散。
23 |                 EchoRequest *req = (EchoRequest*)request;
24 |                 return std::hash<std::string>()(std::to_string(req->code()));
25 |             });
26 |     client.SetDispatcher(std::unique_ptr<ucorf::IDispatcher>(dispatcher));
27 | 
28 |     // 3.设置服务端注册的ZK地址和节点, 格式如下：
29 |     client.SetUrl("zk://127.0.0.1:2181/ucorf/test");
30 | 
31 |     // 4.创建Stub对象，并绑定Client
32 |     UcorfEchoServiceStub stub(&client);
33 | 
34 |     // 5.启动协程
35 |     go [&]{
36 |         co_sleep(500);
37 | 
38 |         // 多次调用, 根据一致性HASH算法分配到ZK节点下的各个服务器
39 |         for (int i = 0; i < 10; ++i)
40 |         {
41 |             // 6.构造RPC调用参数
42 |             EchoRequest request;
43 |             request.set_code(i);
44 | 
45 |             // 7.调用RPC接口
46 |             std::shared_ptr<EchoResponse> rsp = stub.Echo(request);
47 | 
48 |             // 8.获取返回值
49 |             std::cout << "Response: " << rsp->code() << endl;
50 |         }
51 |     };
52 | 
53 |     // 9.启动协程框架主循环
54 |     co_sched.RunLoop();
55 |     return 0;
56 | }
57 | 
58 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | project(ucorf)
 4 | 
 5 | if (CMAKE_BUILD_TYPE)
 6 | else()
 7 |     set(CMAKE_BUILD_TYPE RELEASE)
 8 | endif()
 9 | 
10 | message("CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
11 | 
12 | set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Werror")
13 | set(CMAKE_CXX_FLAGS_PROFILE "-g -pg -O3 ${CMAKE_CXX_FLAGS}")
14 | 
15 | include_directories("${PROJECT_SOURCE_DIR}/ucorf")
16 | include_directories("${PROJECT_SOURCE_DIR}/ucorf/hprose")
17 | include_directories("${PROJECT_SOURCE_DIR}/third_party/libgonet")
18 | include_directories("${PROJECT_SOURCE_DIR}/third_party/libgonet/third_party/libgo")
19 | include_directories("${PROJECT_SOURCE_DIR}/third_party/libgonet/third_party/libgo/libgo")
20 | include_directories("${PROJECT_SOURCE_DIR}/third_party/libgonet/third_party/libgo/libgo/linux")
21 | 
22 | aux_source_directory(${PROJECT_SOURCE_DIR}/ucorf SRC_LIST)
23 | aux_source_directory(${PROJECT_SOURCE_DIR}/ucorf/hprose SRC_LIST)
24 | aux_source_directory(${PROJECT_SOURCE_DIR}/ucorf/hprose/io SRC_LIST)
25 | aux_source_directory(${PROJECT_SOURCE_DIR}/ucorf/hprose/common SRC_LIST)
26 | aux_source_directory(${PROJECT_SOURCE_DIR}/ucorf/hprose/ext SRC_LIST)
27 | #message("source list:\n${SRC_LIST}")
28 | add_library(ucorf ${SRC_LIST})
29 | 
30 | set(CMAKE_INSTALL_PREFIX "/usr/local")
31 | install(DIRECTORY ${PROJECT_SOURCE_DIR}/ucorf/ DESTINATION "include/ucorf" FILES_MATCHING PATTERN *.h PATTERN *.hpp)
32 | install(FILES ${PROJECT_BINARY_DIR}/libucorf.a DESTINATION "lib")
33 | install(PROGRAMS ${PROJECT_SOURCE_DIR}/proto_gen/protoc-gen-rpc DESTINATION "bin")
34 | install(PROGRAMS ${PROJECT_SOURCE_DIR}/proto_gen/descriptor_pb2.py DESTINATION "bin")
35 | install(PROGRAMS ${PROJECT_SOURCE_DIR}/proto_gen/plugin_pb2.py DESTINATION "bin")
36 | 
37 | if (NOT NO_SUB)
38 |     add_subdirectory("${PROJECT_SOURCE_DIR}/third_party/libgonet")
39 | endif()
40 | 


--------------------------------------------------------------------------------
/ucorf/net_transport.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "transport.h"
 5 | #include <libgonet/network.h>
 6 | 
 7 | namespace ucorf
 8 | {
 9 |     class NetTransportServer : public ITransportServer
10 |     {
11 |     public:
12 |         NetTransportServer();
13 |         ~NetTransportServer();
14 | 
15 |         virtual void Shutdown();
16 |         virtual void SetReceiveCb(OnReceiveF const&);
17 |         virtual void SetConnectedCb(OnConnectedF const&);
18 |         virtual void SetDisconnectedCb(OnDisconnectedF const&);
19 |         virtual void SetOption(boost::any const& opt);
20 | 
21 |         virtual boost_ec Listen(std::string const& url);
22 |         virtual void Send(SessId id, const void* data, size_t bytes, OnSndF const& cb = NULL);
23 |         virtual void Send(SessId id, std::vector<char> && buf, OnSndF const& cb = NULL);
24 |         virtual std::string LocalUrl() const;
25 | 
26 |     private:
27 |         ::network::Server s_;
28 |         std::string url_;
29 |     };
30 | 
31 |     class NetTransportClient : public ITransportClient
32 |     {
33 |     public:
34 |         NetTransportClient();
35 |         ~NetTransportClient();
36 | 
37 |         virtual void Shutdown();
38 |         virtual void SetReceiveCb(OnReceiveF const&);
39 |         virtual void SetConnectedCb(OnConnectedF const&);
40 |         virtual void SetDisconnectedCb(OnDisconnectedF const&);
41 |         virtual void SetOption(boost::any const& opt);
42 | 
43 |         virtual boost_ec Connect(std::string const& url);
44 |         virtual void Send(const void* data, size_t bytes, OnSndF const& cb = NULL);
45 |         virtual void Send(std::vector<char> && buf, OnSndF const& cb = NULL);
46 |         virtual bool IsEstab();
47 |         virtual std::string RemoteUrl() const;
48 | 
49 |     private:
50 |         ::network::Client c_;
51 |         std::string url_;
52 |     };
53 | 
54 | } //namespace ucorf
55 | 


--------------------------------------------------------------------------------
/test/bmserver.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/server.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include "echo.rpc.h"
 4 | #include <iostream>
 5 | #include <boost/smart_ptr/make_shared.hpp>
 6 | #include <boost/thread.hpp>
 7 | using std::cout;
 8 | using std::endl;
 9 | using namespace Echo;
10 | 
11 | static std::atomic<size_t> g_count{0};
12 | 
13 | struct MyEcho : public ::Echo::UcorfEchoService
14 | {
15 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
16 |     {
17 |         ++g_count;
18 |         response.set_code(request.code());
19 |         return true;
20 |     }
21 | };
22 | 
23 | void show_status()
24 | {
25 |     static size_t last_count = 0;
26 |     size_t qps = g_count - last_count;
27 |     last_count = g_count;
28 |     cout << "qps: " << qps << endl;
29 | }
30 | 
31 | int main(int argc, char **argv)
32 | {
33 |     using namespace ucorf;
34 | 
35 |     if (argc > 1 && std::string(argv[1]) == "-h") {
36 |         printf("Usage: bmclient.t [ThreadCount] [Address]\n");
37 |         return 0;
38 |     }
39 | 
40 |     int thread_c = 1;
41 |     if (argc > 1)
42 |         thread_c = atoi(argv[1]);
43 | 
44 |     std::string url = "tcp://127.0.0.1:48080";
45 |     if (argc > 2)
46 |         url = argv[2];
47 | 
48 |     ::network::OptionsUser tp_opt;
49 |     tp_opt.max_pack_size_ = 40960;
50 |     auto opt = boost::make_shared<Option>();
51 |     opt->transport_opt = tp_opt;
52 | 
53 |     Server server;
54 |     server.SetOption(opt).RegisterService(boost::shared_ptr<IService>(new MyEcho));
55 |     boost_ec ec = server.Listen(url);
56 |     if (ec) {
57 |         cout << "listen error: " << ec.message() << endl;
58 |         return 1;
59 |     } else {
60 |         cout << "start success, listen " << url << ", thread=" << thread_c << endl;
61 |     }
62 | 
63 |     go []{
64 |         for (;;) {
65 |             show_status();
66 |             co_sleep(1000);
67 |         }
68 |     };
69 | 
70 |     boost::thread_group tg;
71 |     for (int i = 0; i < thread_c; ++i)
72 |         tg.create_thread([]{ co_sched.RunLoop(); });
73 |     tg.join_all();
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/ucorf/server_impl.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "transport.h"
 5 | #include "message.h"
 6 | #include "option.h"
 7 | #include "server_register.h"
 8 | 
 9 | namespace ucorf
10 | {
11 |     struct Session
12 |     {
13 |         SessId sess;
14 |         ITransportServer *transport;
15 |         IHeaderPtr header;
16 |     };
17 | 
18 |     class IService;
19 |     class ServerImpl
20 |     {
21 |     public:
22 |         typedef boost::function<IMessage*(std::string const&, std::string const&)> MessageFactory;
23 | 
24 |         ServerImpl();
25 |         ~ServerImpl();
26 | 
27 |         ServerImpl& SetOption(boost::shared_ptr<Option> opt);
28 | 
29 |         bool RegisterTo(std::string const& url);
30 | 
31 |         bool RegisterService(boost::shared_ptr<IService> service);
32 | 
33 |         void RemoveService(std::string const& service_name);
34 | 
35 |         boost_ec Listen(std::string const& url);
36 | 
37 |         /// --------------------------- extend method ---------------------------
38 |     public:
39 |         ServerImpl& BindTransport(std::unique_ptr<ITransportServer> && transport);
40 |         ServerImpl& SetHeaderFactory(HeaderFactory const& head_factory);
41 |         ServerImpl& SetRegister(boost::shared_ptr<IServerRegister> reg);
42 |         /// ---------------------------------------------------------------------
43 | 
44 |     private:
45 |         void OnConnected(ITransportServer *tp, SessId sess_id);
46 |         void OnDisconnected(ITransportServer *tp, SessId sess_id, boost_ec const& ec);
47 |         size_t OnReceiveData(ITransportServer *tp, SessId sess_id, const char* data, size_t bytes);
48 | 
49 |         bool DispatchMsg(Session & sess, const char* data, size_t bytes);
50 | 
51 |     private:
52 |         typedef std::map<std::string, boost::shared_ptr<IService>> ServiceMap;
53 |         typedef std::list<std::unique_ptr<ITransportServer>> TransportList;
54 | 
55 |         ServiceMap services_;
56 |         boost::shared_ptr<Option> opt_;
57 |         boost::shared_ptr<IServerRegister> register_;
58 |         HeaderFactory head_factory_;
59 |         TransportList transports_;
60 |     };
61 | 
62 | } //namespace ucorf
63 | 


--------------------------------------------------------------------------------
/test/hprose_bmserver.cpp:
--------------------------------------------------------------------------------
 1 | #include <ucorf/server.h>
 2 | #include <ucorf/net_transport.h>
 3 | #include <ucorf/hprose/hprose_service.h>
 4 | #include <iostream>
 5 | #include <boost/smart_ptr/make_shared.hpp>
 6 | #include <boost/thread.hpp>
 7 | using std::cout;
 8 | using std::endl;
 9 | using namespace ucorf;
10 | using namespace ucorf::hprose;
11 | 
12 | static std::atomic<size_t> g_count{0};
13 | 
14 | int add(int v)
15 | {
16 | //    cout << "call add, value=" << v << endl;
17 |     ++g_count;
18 |     return v + v;
19 | }
20 | 
21 | void show_status()
22 | {
23 |     static size_t last_count = 0;
24 |     size_t qps = g_count - last_count;
25 |     last_count = g_count;
26 |     cout << "qps: " << qps << endl;
27 | }
28 | 
29 | int main(int argc, char **argv)
30 | {
31 | 
32 |     if (argc > 1 && std::string(argv[1]) == "-h") {
33 |         printf("Usage: bmclient.t [ThreadCount] [Address]\n");
34 |         return 0;
35 |     }
36 | 
37 |     int thread_c = 1;
38 |     if (argc > 1)
39 |         thread_c = atoi(argv[1]);
40 | 
41 |     std::string url = "tcp://127.0.0.1:48080";
42 |     if (argc > 2)
43 |         url = argv[2];
44 | 
45 |     ::network::OptionsUser tp_opt;
46 |     tp_opt.max_pack_size_ = 40960;
47 |     auto opt = boost::make_shared<Option>();
48 |     opt->transport_opt = tp_opt;
49 | 
50 |     Hprose_Service *hp_srv = new Hprose_Service;
51 |     hp_srv->RegisterFunction("add", boost::function<int(int)>(&add));
52 |     boost::shared_ptr<IService> srv(hp_srv);
53 |     Server server;
54 |     server.SetOption(opt);
55 |     server.SetHeaderFactory(&Hprose_Head::Factory);
56 |     server.RegisterService(srv);
57 | 
58 |     boost_ec ec = server.Listen(url);
59 |     if (ec) {
60 |         cout << "listen error: " << ec.message() << endl;
61 |         return 1;
62 |     } else {
63 |         cout << "start success, listen " << url << ", thread=" << thread_c << endl;
64 |     }
65 | 
66 |     go []{
67 |         for (;;) {
68 |             show_status();
69 |             co_sleep(1000);
70 |         }
71 |     };
72 | 
73 |     boost::thread_group tg;
74 |     for (int i = 0; i < thread_c; ++i)
75 |         tg.create_thread([]{ co_sched.RunLoop(); });
76 |     tg.join_all();
77 |     return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_service.cpp:
--------------------------------------------------------------------------------
 1 | #include "hprose_service.h"
 2 | #include <sstream>
 3 | 
 4 | namespace ucorf {
 5 | namespace hprose {
 6 | 
 7 | std::unique_ptr<IMessage> Hprose_Service::CallMethod(std::string const&,
 8 |         const char *request_data, size_t request_bytes)
 9 | {
10 |     Buffer reader(request_data, request_bytes);
11 | 
12 |     char flag = reader.get();
13 |     if (flag == hprose::TagEnd) {
14 |         // return function list.
15 |         return std::unique_ptr<IMessage>(new Hprose_Message(GetFunctionList()));
16 |     }
17 | 
18 |     if (flag == hprose::TagCall) {
19 |         std::string method;
20 |         if (!reader.Read(method, true))
21 |             return std::unique_ptr<IMessage>(new Hprose_Message("Es10\"Error Args\"z"));
22 |         return std::unique_ptr<IMessage>(new Hprose_Message(Call(method, reader)));
23 |     }
24 | 
25 |     Buffer writer;
26 |     writer.Write(hprose::TagError);
27 |     writer.Write("No support protocol tag.");
28 |     writer.Write(hprose::TagEnd);
29 |     return std::unique_ptr<IMessage>(new Hprose_Message(writer.str()));
30 | }
31 | 
32 | std::string Hprose_Service::GetFunctionList()
33 | {
34 |     Buffer writer;
35 |     writer.Write(hprose::TagFunctions);
36 |     std::vector<std::string> funcs;
37 |     funcs.reserve(functions_.size());
38 |     for (auto &kv : functions_)
39 |         funcs.push_back(kv.first);
40 |     writer.Write(funcs);
41 |     writer.Write(hprose::TagEnd);
42 |     return writer.str();
43 | }
44 | 
45 | std::string Hprose_Service::Call(std::string const& method, Buffer & reader)
46 | {
47 |     boost::shared_ptr<CalleeBase> sptr;
48 | 
49 |     {
50 |         std::unique_lock<co_mutex> lock(func_mutex_);
51 |         auto it = functions_.find(method);
52 |         if (functions_.end() == it)
53 |             it = functions_.find("*");
54 | 
55 |         if (functions_.end() != it)
56 |             sptr = it->second;
57 |     }
58 | 
59 |     if (!sptr) {
60 |         // no callee, returns error.
61 |         Buffer writer;
62 |         writer.Write(hprose::TagError);
63 |         writer.Write(std::string("No Callee ") + method);
64 |         writer.Write(hprose::TagEnd);
65 |         return writer.str();
66 |     }
67 | 
68 |     return sptr->Call(reader);
69 | }
70 | 
71 | } //namespace hprose
72 | } //namespace ucorf
73 | 


--------------------------------------------------------------------------------
/ucorf/dispatcher.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "message.h"
 5 | #include "transport.h"
 6 | #include "conhash.h"
 7 | 
 8 | namespace ucorf
 9 | {
10 |     enum class eDispatchAlgorithm
11 |     {
12 |         robin,
13 |         random,
14 |         con_hash,
15 |     };
16 | 
17 |     class IDispatcher
18 |     {
19 |     public:
20 |         virtual ~IDispatcher() {}
21 | 
22 |         virtual void Add(boost::shared_ptr<ITransportClient> tp) = 0;
23 |         virtual void Del(boost::shared_ptr<ITransportClient> tp) = 0;
24 | 
25 |         virtual boost::shared_ptr<ITransportClient> Get( std::string const& service_name,
26 |                 std::string const& method_name, IMessage *request) = 0;
27 |     };
28 | 
29 |     class RobinDispatcher : public IDispatcher
30 |     {
31 |     public:
32 |         virtual void Add(boost::shared_ptr<ITransportClient> tp);
33 |         virtual void Del(boost::shared_ptr<ITransportClient> tp);
34 | 
35 |         virtual boost::shared_ptr<ITransportClient> Get( std::string const& service_name,
36 |                 std::string const& method_name, IMessage *request);
37 | 
38 |     private:
39 |         std::vector<boost::shared_ptr<ITransportClient>> tp_list_;
40 |         std::size_t robin_idx_{0};
41 |         co_rwmutex mutex_;
42 |     };
43 | 
44 |     class HashDispatcher : public IDispatcher
45 |     {
46 |     public:
47 |         typedef boost::function<std::size_t(std::string const& service_name,
48 |                 std::string const& method_name, IMessage *request)> HashF;
49 |         typedef boost::function<std::string(std::string const& url)> HashTagF;
50 | 
51 |         virtual void Add(boost::shared_ptr<ITransportClient> tp);
52 |         virtual void Del(boost::shared_ptr<ITransportClient> tp);
53 | 
54 |         virtual boost::shared_ptr<ITransportClient> Get(std::string const& service_name,
55 |                 std::string const& method_name, IMessage *request);
56 | 
57 |         void SetVirtualCount(std::size_t vir_count);
58 |         void SetHashFunction(HashF fn);
59 |         void SetHashTagFunction(HashTagF fn);
60 | 
61 |     private:
62 |         std::string GetHashKey(boost::shared_ptr<ITransportClient> tp);
63 | 
64 |     private:
65 |         co_rwmutex mutex_;
66 |         std::size_t vir_count_ = 0;
67 |         HashF hash_fn_;
68 |         HashTagF hash_tag_fn_;
69 |         std::size_t hash_idx_ = 0;
70 |         con_hashtable<boost::shared_ptr<ITransportClient>> conhash_table_;
71 |     };
72 | 
73 | } //namespace ucorf
74 | 


--------------------------------------------------------------------------------
/ucorf/message.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | 
 5 | namespace ucorf
 6 | {
 7 |     enum class eHeaderType
 8 |     {
 9 |         request,
10 |         oneway_request,
11 |         response,
12 |     };
13 | 
14 |     class IHeader
15 |     {
16 |     public:
17 |         virtual ~IHeader() {}
18 | 
19 |         virtual void SetId(std::size_t id) = 0;
20 |         virtual void SetType(eHeaderType type) = 0;
21 |         virtual void SetFollowBytes(std::size_t bytes) = 0;
22 |         virtual void SetService(std::string const& srv) = 0;
23 |         virtual void SetMethod(std::string const& method) = 0;
24 | 
25 |         virtual std::size_t GetId() = 0;
26 |         virtual eHeaderType GetType() = 0;
27 |         virtual std::size_t GetFollowBytes() = 0;
28 |         virtual std::string GetService() = 0;
29 |         virtual std::string GetMethod() = 0;
30 | 
31 |         virtual bool Serialize(void* buf, std::size_t len) = 0;
32 |         virtual std::size_t ByteSize() = 0;
33 |         virtual std::size_t Parse(const void* buf, std::size_t len) = 0;
34 |     };
35 |     typedef boost::shared_ptr<IHeader> IHeaderPtr;
36 |     typedef boost::function<IHeaderPtr()> HeaderFactory;
37 | 
38 |     class IMessage
39 |     {
40 |     public:
41 |         virtual ~IMessage() {}
42 | 
43 |         virtual bool Serialize(void* buf, std::size_t len) = 0;
44 |         virtual std::size_t ByteSize() = 0;
45 |         virtual std::size_t Parse(const void* buf, std::size_t len) = 0;
46 |     };
47 | 
48 |     struct UcorfHead : public IHeader
49 |     {
50 |     public:
51 |         virtual void SetId(std::size_t id);
52 |         virtual void SetType(eHeaderType type);
53 |         virtual void SetFollowBytes(std::size_t bytes);
54 |         virtual void SetService(std::string const& srv);
55 |         virtual void SetMethod(std::string const& mthd);
56 | 
57 |         virtual std::size_t GetId();
58 |         virtual eHeaderType GetType();
59 |         virtual std::size_t GetFollowBytes();
60 |         virtual std::string GetService();
61 |         virtual std::string GetMethod();
62 | 
63 |         virtual bool Serialize(void* buf, std::size_t len);
64 |         virtual std::size_t ByteSize();
65 |         virtual std::size_t Parse(const void* buf, std::size_t len);
66 | 
67 |         static IHeaderPtr Factory();
68 | 
69 |         static const unsigned char magic_code = 0xf8;
70 |         uint8_t calltype;
71 |         uint32_t callid;
72 |         uint32_t body_length;
73 |         std::string service;
74 |         std::string method;
75 |     };
76 | 
77 | } //namespace ucorf
78 | 


--------------------------------------------------------------------------------
/ucorf/server_finder.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "transport.h"
 5 | #include "option.h"
 6 | #include "zookeeper.h"
 7 | 
 8 | namespace ucorf
 9 | {
10 |     class ServerFinder
11 |     {
12 |     public:
13 |         enum class eMode
14 |         {
15 |             single,
16 |             zk,
17 |         };
18 | 
19 |         typedef boost::function<void(boost::shared_ptr<ITransportClient>, SessId)> OnConnectedF;
20 |         typedef boost::function<void(boost::shared_ptr<ITransportClient>, SessId, boost_ec const&)> OnDisconnectedF;
21 |         typedef boost::function<size_t(boost::shared_ptr<ITransportClient>, SessId, const char*, size_t)> OnReceiveF;
22 |         typedef boost::function<ITransportClient*()> TransportFactory;
23 | 
24 |         ServerFinder();
25 |         virtual ~ServerFinder();
26 | 
27 |         virtual void Init(std::string const& url, TransportFactory const& factory);
28 | 
29 |         void SetConnectedCb(OnConnectedF const& cb);
30 |         void SetReceiveCb(OnReceiveF const& cb);
31 |         void SetDisconnectedCb(OnDisconnectedF const& cb);
32 |         void SetOption(boost::shared_ptr<Option> opt);
33 |         boost_ec ReConnect();
34 | 
35 |     private:
36 |         void OnZookeeperChilds(ZookeeperClient::Children const& nodes,
37 |                 boost::shared_ptr<bool> token, boost::shared_ptr<co_mutex> mutex);
38 | 
39 |         void OnDisconnected(boost::weak_ptr<ITransportClient> tp,
40 |                 SessId id, boost_ec const& ec, std::string url,
41 |                 boost::shared_ptr<bool> token, boost::shared_ptr<co_mutex> mutex);
42 | 
43 |         void RecursiveConnect(boost::shared_ptr<ITransportClient> sptr, std::string url,
44 |                 boost::shared_ptr<bool> token, boost::shared_ptr<co_mutex> mutex);
45 | 
46 |     private:
47 |         OnConnectedF on_connect_;
48 |         OnReceiveF on_receive_;
49 |         OnDisconnectedF on_disconnect_;
50 |         TransportFactory tp_factory_;
51 |         bool inited_;
52 |         std::string url_;
53 |         eMode mode_;
54 |         boost::shared_ptr<Option> opt_;
55 | 
56 |         // single address
57 |         boost::shared_ptr<ITransportClient> single_tp_;
58 | 
59 |         // zookeeper address and path
60 |         boost::shared_ptr<co_mutex> destroy_mutex_;
61 |         boost::shared_ptr<bool> token_;
62 |         std::string zk_addr_;
63 |         std::string zk_path_;
64 |         typedef std::map<std::string, boost::shared_ptr<ITransportClient>> TransportGroup;
65 |         TransportGroup transports_;
66 |     };
67 | 
68 | } //namespace ucorf
69 | 


--------------------------------------------------------------------------------
/ucorf/conhash.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | #include <map>
 5 | #include <string>
 6 | 
 7 | namespace ucorf
 8 | {
 9 | 
10 | template <typename V, template <typename> class H = std::hash>
11 |     class con_hashtable
12 |     {
13 |     public:
14 |         typedef V value_t;
15 | 
16 |         template <typename T>
17 |         std::size_t insert(T const& key, value_t value, std::size_t vir_count = 64)
18 |         {
19 |             std::size_t ori_hashcode = hash(key);
20 |             if (vir_table_.count(ori_hashcode)) return 0;
21 |             auto &vir_list = vir_table_[ori_hashcode];
22 | 
23 |             std::string ori_str = std::to_string(ori_hashcode);
24 |             for (std::size_t i = 0; i < vir_count; ++i)
25 |             {
26 |                 std::string str = ori_str + "-" + std::to_string(i);
27 |                 std::size_t hashcode = hash(str);
28 |                 if (table_.insert(std::make_pair(hashcode, value)).second)
29 |                     vir_list.push_back(hashcode);
30 |             }
31 | 
32 |             if (vir_list.empty()) {
33 |                 vir_table_.erase(ori_hashcode);
34 |                 return 0;
35 |             }
36 | 
37 |             return vir_list.size();
38 |         }
39 | 
40 |         template <typename T>
41 |         bool erase(T const& key)
42 |         {
43 |             std::size_t ori_hashcode = hash(key);
44 |             auto it = vir_table_.find(ori_hashcode);
45 |             if (vir_table_.end() == it) return false;
46 |             auto &vir_list = it->second;
47 |             for (auto hashcode : vir_list)
48 |                 table_.erase(hashcode);
49 |             vir_table_.erase(it);
50 |             return true;
51 |         }
52 | 
53 |         template <typename T>
54 |         value_t get(T const& key)
55 |         {
56 |             return hget(hash(key));
57 |         }
58 | 
59 |         value_t hget(std::size_t hash_code)
60 |         {
61 |             if (table_.empty()) return value_t();
62 | 
63 |             auto it = table_.lower_bound(hash_code);
64 |             if (it == table_.end())
65 |                 it = table_.begin();
66 | 
67 |             return it->second;
68 |         }
69 | 
70 |     private:
71 |         template <typename T>
72 |         std::size_t hash(T const& key)
73 |         {
74 |             return H<T>()(key);
75 |         }
76 | 
77 |     private:
78 |         typedef std::map<std::size_t, V> table_t;
79 |         typedef std::map<std::size_t, std::vector<std::size_t> > vir_table_t;
80 |         table_t table_;
81 |         vir_table_t vir_table_;
82 |     };
83 | 
84 | 
85 | } //namespace ucorf
86 | 


--------------------------------------------------------------------------------
/ucorf/zookeeper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "option.h"
 5 | #include <zookeeper/zookeeper.h>
 6 | #include <boost/noncopyable.hpp>
 7 | 
 8 | namespace ucorf
 9 | {
10 |     class ZookeeperClient : public boost::noncopyable
11 |     {
12 |     public:
13 |         enum class eCreateNodeFlags
14 |         {
15 |             normal,
16 |             ephemeral,
17 |             sequence,
18 |         };
19 | 
20 |         typedef std::vector<std::string> Children;
21 |         typedef boost::function<void(Children const&)> WatchCb;
22 |         typedef std::map<void*, WatchCb> WatcherMap;
23 |         typedef std::map<std::string, WatcherMap> ZkWatchers;
24 |         typedef boost::function<void()> OnWatchF;
25 | 
26 |         ZookeeperClient();
27 | 
28 |         void Init(std::string zk_host);
29 | 
30 |         bool WaitForConnected(unsigned timeout_ms);
31 | 
32 |         bool Watch(std::string path, WatchCb const& cb, void* key);
33 | 
34 |         void Unwatch(std::string path, void* key);
35 | 
36 |         bool CreateNode(std::string path, eCreateNodeFlags flags,
37 |                 bool recursive = true, bool is_lock = true);
38 | 
39 |         bool DelayCreateEphemeralNode(std::string path, bool is_lock = true);
40 | 
41 |         bool DeleteNode(std::string path);
42 | 
43 |     private:
44 |         void Connect();
45 |         void OnWatch(zhandle_t *zh, int type, int state, std::string path);
46 |         bool __Watch(std::string path, WatchCb const& cb = NULL);
47 |         static void __watcher_fn(zhandle_t *zh, int type, 
48 |                 int state, const char *path, void *watcherCtx);
49 | 
50 |     private:
51 |         zhandle_t *zk_ = nullptr;
52 |         std::string host_;
53 |         ZkWatchers zk_watchers_;
54 |         std::set<std::string> ephemeral_nodes_;
55 |         co_chan<OnWatchF> event_chan_;
56 |         co_mutex mutex_;
57 |     };
58 | 
59 |     class ZookeeperClientMgr : public boost::noncopyable
60 |     {
61 |     public:
62 |         static ZookeeperClientMgr& getInstance();
63 | 
64 |         void SetTimeout(int timeo);
65 |         int GetTimeout();
66 | 
67 |         std::pair<std::string, std::string> ParseZookeeperUrl(std::string url);
68 |         std::string Url2ZookeeperNode(std::string url);
69 |         std::string ZookeeperNode2Url(std::string node);
70 | 
71 |         boost::shared_ptr<ZookeeperClient> GetZookeeperClient(std::string zk_host);
72 | 
73 |     private:
74 |         std::map<std::string, boost::shared_ptr<ZookeeperClient> > zk_clients_;
75 |         int zk_timeout_ = 10000;
76 |         co_mutex mutex_;
77 |     };
78 | 
79 | } //namespace ucorf
80 | 


--------------------------------------------------------------------------------
/ucorf/message.cpp:
--------------------------------------------------------------------------------
 1 | #include "message.h"
 2 | #include <boost/pool/object_pool.hpp>
 3 | 
 4 | namespace ucorf
 5 | {
 6 |     void UcorfHead::SetId(std::size_t id)
 7 |     {
 8 |         callid = id;
 9 |     }
10 |     void UcorfHead::SetType(eHeaderType type)
11 |     {
12 |         calltype = (uint8_t)type;
13 |     }
14 |     void UcorfHead::SetFollowBytes(std::size_t bytes)
15 |     {
16 |         body_length = bytes;
17 |     }
18 |     void UcorfHead::SetService(std::string const& srv)
19 |     {
20 |         service = srv;
21 |     }
22 |     void UcorfHead::SetMethod(std::string const& mthd)
23 |     {
24 |         method = mthd;
25 |     }
26 | 
27 |     std::size_t UcorfHead::GetId()
28 |     {
29 |         return callid;
30 |     }
31 |     eHeaderType UcorfHead::GetType()
32 |     {
33 |         return (eHeaderType)calltype;
34 |     }
35 |     std::size_t UcorfHead::GetFollowBytes()
36 |     {
37 |         return body_length;
38 |     }
39 |     std::string UcorfHead::GetService()
40 |     {
41 |         return service;
42 |     }
43 |     std::string UcorfHead::GetMethod()
44 |     {
45 |         return method;
46 |     }
47 | 
48 |     bool UcorfHead::Serialize(void* buf, std::size_t len)
49 |     {
50 |         if (len < ByteSize()) return false;
51 |         *(unsigned char*)buf = magic_code;
52 |         *(uint8_t*)((char*)buf + 1) = calltype;
53 |         *(uint32_t*)((char*)buf + 2) = htonl(callid);
54 |         *(uint32_t*)((char*)buf + 6) = htonl(body_length);
55 |         *(uint16_t*)((char*)buf + 10) = htons(service.size());
56 |         *(uint16_t*)((char*)buf + 12) = htons(method.size());
57 |         memcpy((char*)buf + 14, service.data(), service.size());
58 |         memcpy((char*)buf + 14 + service.size(), method.data(), method.size());
59 |         return true;
60 |     }
61 |     std::size_t UcorfHead::ByteSize()
62 |     {
63 |         return sizeof(unsigned char) + sizeof(calltype) +
64 |             sizeof(callid) + sizeof(body_length) +
65 |             4 + service.size() + method.size();
66 |     }
67 |     std::size_t UcorfHead::Parse(const void* buf, std::size_t len)
68 |     {
69 |         if (len < 14) return 0;
70 |         if (*(unsigned char*)buf != magic_code) return 0;
71 |         uint16_t service_len = htons(*(uint16_t*)((char*)buf + 10));
72 |         uint16_t method_len = htons(*(uint16_t*)((char*)buf + 12));
73 |         if ((uint16_t)len < 14 + service_len + method_len) return 0;
74 | 
75 |         calltype = *(uint8_t*)((char*)buf + 1);
76 |         callid = htonl(*(uint32_t*)((char*)buf + 2));
77 |         body_length = htonl(*(uint32_t*)((char*)buf + 6));
78 |         service.assign((char*)buf + 14, service_len);
79 |         method.assign((char*)buf + 14 + service_len, method_len);
80 |         return 14 + service_len + method_len;
81 |     }
82 | 
83 |     IHeaderPtr UcorfHead::Factory()
84 |     {
85 |         return boost::static_pointer_cast<IHeader>(boost::make_shared<UcorfHead>());
86 |     }
87 | 
88 | } //namespace ucorf
89 | 


--------------------------------------------------------------------------------
/ucorf/dispatcher.cpp:
--------------------------------------------------------------------------------
 1 | #include "dispatcher.h"
 2 | #include "logger.h"
 3 | 
 4 | namespace ucorf
 5 | {
 6 |     // Robin
 7 |     void RobinDispatcher::Add(boost::shared_ptr<ITransportClient> tp)
 8 |     {
 9 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
10 |         tp_list_.push_back(tp);
11 |     }
12 |     void RobinDispatcher::Del(boost::shared_ptr<ITransportClient> tp)
13 |     {
14 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
15 |         auto it = std::find(tp_list_.begin(), tp_list_.end(), tp);
16 |         if (it != tp_list_.end())
17 |             tp_list_.erase(it);
18 |     }
19 | 
20 |     boost::shared_ptr<ITransportClient> RobinDispatcher::Get( std::string const& service_name,
21 |             std::string const& method_name, IMessage *request)
22 |     {
23 |         std::unique_lock<co_rmutex> lock(mutex_.reader());
24 |         if (tp_list_.empty())
25 |             return boost::shared_ptr<ITransportClient>();
26 | 
27 |         ++robin_idx_;
28 |         robin_idx_ = robin_idx_ % tp_list_.size();
29 |         return tp_list_[robin_idx_];
30 |     }
31 | 
32 |     // Hash
33 |     void HashDispatcher::Add(boost::shared_ptr<ITransportClient> tp)
34 |     {
35 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
36 |         std::string hashkey = GetHashKey(tp);
37 |         if (!vir_count_)
38 |             conhash_table_.insert(hashkey, tp);
39 |         else
40 |             conhash_table_.insert(hashkey, tp, vir_count_);
41 |     }
42 |     void HashDispatcher::Del(boost::shared_ptr<ITransportClient> tp)
43 |     {
44 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
45 |         std::string hashkey = GetHashKey(tp);
46 |         conhash_table_.erase(hashkey);
47 |     }
48 |     boost::shared_ptr<ITransportClient> HashDispatcher::Get(
49 |             std::string const& service_name,
50 |             std::string const& method_name, IMessage *request)
51 |     {
52 |         std::unique_lock<co_rmutex> lock(mutex_.reader());
53 |         if (hash_fn_) {
54 |             std::size_t hashcode = hash_fn_(service_name, method_name, request);
55 |             return conhash_table_.hget(hashcode);
56 |         } else {
57 |             return conhash_table_.get(std::to_string(++hash_idx_));
58 |         }
59 |     }
60 |     void HashDispatcher::SetVirtualCount(std::size_t vir_count)
61 |     {
62 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
63 |         vir_count_ = vir_count;
64 |     }
65 |     void HashDispatcher::SetHashFunction(HashF fn)
66 |     {
67 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
68 |         hash_fn_ = fn;
69 |     }
70 |     void HashDispatcher::SetHashTagFunction(HashTagF fn)
71 |     {
72 |         std::unique_lock<co_wmutex> lock(mutex_.writer());
73 |         hash_tag_fn_ = fn;
74 |     }
75 |     std::string HashDispatcher::GetHashKey(boost::shared_ptr<ITransportClient> tp)
76 |     {
77 |         std::string url = tp->RemoteUrl();
78 |         if (hash_tag_fn_)
79 |             return hash_tag_fn_(url);
80 | 
81 |         return url;
82 |     }
83 | 
84 | } //namespace ucorf
85 | 


--------------------------------------------------------------------------------
/ucorf/logger.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdio>
 4 | #include <string>
 5 | #include <libgo/coroutine.h>
 6 | 
 7 | namespace ucorf
 8 | {
 9 |     class Logger
10 |     {
11 |     public:
12 |         enum class eLogLevel
13 |         {
14 |             verbose,
15 |             debug,
16 |             info,
17 |             notice,
18 |             warn,
19 |             error,
20 |             fatal,
21 |         };
22 | 
23 |         enum class eLogFlag
24 |         {
25 |             time = 0x1,
26 |             file = 0x1 << 1,
27 |             func = 0x1 << 2,
28 |             line = 0x1 << 3,
29 |             tid  = 0x1 << 4,
30 |             all  = 0x7fffffff,
31 |         };
32 | 
33 |         ~Logger();
34 | 
35 |         static Logger& default_instance();
36 | 
37 |         bool Reopen(std::string destination);
38 | 
39 |         void SetLevel(eLogLevel level);
40 | 
41 |         void SetMask(size_t mask);
42 | 
43 |         void Write(eLogLevel level, const char* file,
44 |                 int line, const char* func,
45 |                 const char* fmt, ...)
46 |             __attribute__((format(printf, 6, 7)));
47 | 
48 |         inline eLogLevel GetLevel() {
49 |             return level_; 
50 |         }
51 | 
52 |     private:
53 |         std::FILE* file_ = stdout;
54 |         co_rwmutex rw_mtx_;
55 |         std::string destination_;
56 |         eLogLevel level_ = eLogLevel::verbose;
57 |         size_t mask_ = (size_t)eLogFlag::all & ~(size_t)eLogFlag::tid;
58 |     };
59 | 
60 | #define _ucorf_log(lg, level, fmt, ...) \
61 |     do { \
62 |         if (level >= lg.GetLevel()) \
63 |             lg.Write(level, __FILE__, __LINE__, __FUNCTION__, fmt, ## __VA_ARGS__); \
64 |     } while(0)
65 | 
66 | #define _ucorf_log_verb(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::verbose), fmt, ## __VA_ARGS__);
67 | #define ucorf_log_verb(fmt, ...) _ucorf_log_verb((Logger::default_instance()), fmt, ## __VA_ARGS__);
68 | 
69 | #define _ucorf_log_debug(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::debug), fmt, ## __VA_ARGS__);
70 | #define ucorf_log_debug(fmt, ...) _ucorf_log_debug((Logger::default_instance()), fmt, ## __VA_ARGS__);
71 | 
72 | #define _ucorf_log_info(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::info), fmt, ## __VA_ARGS__);
73 | #define ucorf_log_info(fmt, ...) _ucorf_log_info((Logger::default_instance()), fmt, ## __VA_ARGS__);
74 | 
75 | #define _ucorf_log_notice(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::notice), fmt, ## __VA_ARGS__);
76 | #define ucorf_log_notice(fmt, ...) _ucorf_log_notice((Logger::default_instance()), fmt, ## __VA_ARGS__);
77 | 
78 | #define _ucorf_log_warn(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::warn), fmt, ## __VA_ARGS__);
79 | #define ucorf_log_warn(fmt, ...) _ucorf_log_warn((Logger::default_instance()), fmt, ## __VA_ARGS__);
80 | 
81 | #define _ucorf_log_error(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::error), fmt, ## __VA_ARGS__);
82 | #define ucorf_log_error(fmt, ...) _ucorf_log_error((Logger::default_instance()), fmt, ## __VA_ARGS__);
83 | 
84 | #define _ucorf_log_fatal(lg, fmt, ...) _ucorf_log(lg, (Logger::eLogLevel::fatal), fmt, ## __VA_ARGS__);
85 | #define ucorf_log_fatal(fmt, ...) _ucorf_log_fatal((Logger::default_instance()), fmt, ## __VA_ARGS__);
86 | 
87 | } //namespace ucorf
88 | 


--------------------------------------------------------------------------------
/ucorf/client_impl.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "preheader.h"
 4 | #include "message.h"
 5 | #include "transport.h"
 6 | #include "option.h"
 7 | #include "server_finder.h"
 8 | 
 9 | namespace ucorf
10 | {
11 |     class IServiceStub;
12 |     class ITransportClient;
13 |     class IDispatcher;
14 |     class ClientImpl
15 |     {
16 |     public:
17 |         typedef boost::function<ITransportClient*()> TransportFactory;
18 | 
19 |         ClientImpl();
20 |         ~ClientImpl();
21 | 
22 |         ClientImpl& SetOption(boost::shared_ptr<Option> opt);
23 | 
24 |         ClientImpl& SetUrl(std::string const& url);
25 | 
26 |         boost_ec Call(std::string const& service_name,
27 |                 std::string const& method_name,
28 |                 IMessage *request, IMessage *response);
29 | 
30 |         /// ------------------------ extend method --------------------------
31 |     public:
32 |         ClientImpl& SetDispatcher(std::unique_ptr<IDispatcher> && dispatcher);
33 |         ClientImpl& SetHeaderFactory(HeaderFactory const& head_factory);
34 |         ClientImpl& SetServerFinder(std::unique_ptr<ServerFinder> && srv_finder);
35 |         ClientImpl& SetTransportFactory(TransportFactory const& factory);
36 |         /// -----------------------------------------------------------------
37 |         
38 |     private:
39 |         void OnConnected(boost::shared_ptr<ITransportClient> tp, SessId sess_id);
40 |         void OnDisconnected(boost::shared_ptr<ITransportClient> tp, SessId sess_id, boost_ec const& ec);
41 |         size_t OnReceiveData(boost::shared_ptr<ITransportClient> tp, SessId sess_id, const char* data, size_t bytes);
42 |         void OnResponse(boost::shared_ptr<ITransportClient> tp, IHeaderPtr header, const char* data, size_t bytes);
43 | 
44 |     private:
45 |         struct ResponseData
46 |         {
47 |             boost_ec ec;
48 |             IHeaderPtr header;
49 |             std::vector<char> data;
50 | 
51 |             ResponseData() = default;
52 |             ResponseData(boost_ec const& e) : ec(e) {}
53 |         };
54 | 
55 |         // 必须为2的幂
56 |         enum { e_chan_group_count = 0x10 };
57 | 
58 |         typedef std::map<std::string, ITransportClient*> StubMap;
59 |         typedef co_chan<ResponseData> RspChan;
60 |         typedef std::unordered_map<std::size_t, RspChan> RspChanMap;
61 |         struct RspChanGroup
62 |         {
63 |             co_mutex mtxs[e_chan_group_count];
64 |             RspChanMap maps[e_chan_group_count];
65 |             volatile bool closed[e_chan_group_count] = {};
66 |         };
67 |         typedef std::unordered_map<ITransportClient*,
68 |                     boost::shared_ptr<RspChanGroup>> ChannelMap;
69 |         StubMap stubs_;
70 |         std::string url_;
71 |         co_mutex channel_mtx_;
72 |         ChannelMap channels_;
73 |         std::atomic<std::size_t> msg_id_{0};
74 |         std::atomic<std::size_t> wnd_size_{0};
75 | 
76 |         boost::shared_ptr<Option> opt_;
77 |         std::unique_ptr<IDispatcher> dispatcher_;
78 |         HeaderFactory head_factory_;
79 |         std::unique_ptr<ServerFinder> default_srv_finder_;
80 |         std::list<std::unique_ptr<ServerFinder>> srv_finders_;
81 |         TransportFactory tp_factory_;
82 |     };
83 | 
84 | } //namespace ucorf
85 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Ucorf概述
  2 | 使用C++11编写的通用协程RPC框架，尤其适合做微服务架构的服务底层框架。
  3 | 在服务发现、通信协议包头、通信协议包体、底层通信通道、负载均衡算法等维度上均可扩展。
  4 | ####服务发现：
  5 |     默认支持IP直连和Zookeeper服务发现
  6 | ####通信协议：
  7 |     默认使用protobuf，提供protoc插件，自动生成相关代码
  8 | ####底层通信通道：
  9 |     默认支持tcp、udp协议
 10 | ####负载均衡：
 11 |     默认提供robin、一致性hash两种算法
 12 | 
 13 | ## Linux上编译与安装
 14 |   ucorf使用CMake作为构建工具, 在git代码库中执行以下命令:
 15 |   
 16 |     $ git submodule update --init
 17 |     $ mkdir build
 18 |     $ cd build
 19 |     $ cmake .. -DCMAKE_BUILD_TYPE=RELEASE
 20 |     $ sudo make install
 21 |  
 22 |  至此, 安装完成. 如果要编译debug模式的库，将
 23 |  
 24 |     $ cmake .. -DCMAKE_BUILD_TYPE=RELEASE
 25 |  命令换成
 26 |  
 27 |     $ cmake ..
 28 |     
 29 | ## 安装依赖的库
 30 | ### DEBIAN系Linux：
 31 | 
 32 |     $ sudo apt-get install libzookeeper-mt-dev -y
 33 |     $ sudo apt-get install libprotobuf-dev -y
 34 |     $ sudo apt-get install python-protobuf -y
 35 |     $ sudo apt-get install protobuf-compiler -y
 36 |     $ sudo apt-get install libboost-all-dev -y
 37 | 
 38 | ## 基础用法
 39 | #### 一.URL
 40 |   ucorf使用url来表示地址信息, 格式如下:
 41 |   
 42 |     <protocol>://<ip>:<port>
 43 |   例如：
 44 |   
 45 |     tcp://127.0.0.1:8080
 46 |     udp://127.0.0.1:8081
 47 |   目前仅支持tcp和udp两种协议。
 48 |   
 49 | #### 二.协程
 50 |   ucorf是基于libgo协程库实现的，关于协程的好处及相关知识参见: https://github.com/yyzybb537/libgo
 51 |   
 52 | #### 三.协议定义与代码生成
 53 |   ucorf默认使用protobuf作为通信协议.(如果不满足需求, 请自行扩展)
 54 |   
 55 |   protobuf的IDL语法在此不再赘述, 一个简单例子在test/echo.proto中。
 56 |   
 57 |   生成代码命令如下：
 58 |   
 59 |         $ protoc --cpp_out=. echo.proto
 60 |         $ protoc --rpc_out=. echo.proto
 61 |         
 62 |   第一行命令是protobuf自带的生成CPP代码的命令，会生成echo.pb.h和echo.pb.cc两个文件。
 63 |   
 64 |   第二行命令是使用ucorf扩展插件的命令，会生成echo.rpc.h和echo.rpc.cc两个文件。
 65 |   
 66 |   使用时只需#include "echo.rpc.h"即可，ucorf中自带的测试代码均依赖echo.proto生成的代码。
 67 |   
 68 | #### 四.示例
 69 |   一个简单的server:
 70 |   ~~~~~~~~~~cpp
 71 | #include <ucorf/ucorf.h>
 72 | #include "echo.rpc.h"
 73 | #include <iostream>
 74 | using namespace Echo;
 75 | 
 76 | // 1.继承代码生成器生成的类，并重写定义的rpc接口
 77 | struct MyEcho : public ::Echo::UcorfEchoService
 78 | {
 79 |     virtual bool Echo(EchoRequest & request, EchoResponse & response)
 80 |     {
 81 |         // 处理请求
 82 |         response.set_code(request.code());
 83 |         return true;
 84 |     }
 85 | };
 86 | 
 87 | int main()
 88 | {
 89 |     // 2.创建server对象
 90 |     ucorf::Server server;
 91 | 
 92 |     // 3.注册MyEcho服务
 93 |     server.RegisterService(boost::shared_ptr<IService>(new MyEcho));
 94 | 
 95 |     // 4.启动监听端口
 96 |     ucorf::boost_ec ec = server.Listen("tcp://127.0.0.1:8080");     // 监听本机8080端口
 97 | 
 98 |     // 5.启动协程框架主循环
 99 |     co_sched.RunLoop();     
100 | 
101 |     return 0;
102 | }
103 |   ~~~~~~~~~~
104 |   一个简单的client:
105 |   ~~~~~~~~~~cpp
106 | #include <ucorf/ucorf.h>
107 | #include "echo.rpc.h"
108 | #include <iostream>
109 | using namespace Echo;
110 | 
111 | int main(int argc, char **argv)
112 | {
113 |     // 1.创建Client对象
114 |     ucorf::Client client;
115 | 
116 |     // 2.设置服务端地址
117 |     client.SetUrl("tcp://127.0.0.1:8080");
118 | 
119 |     // 3.创建Stub对象，并绑定Client
120 |     UcorfEchoServiceStub stub(&client);
121 | 
122 |     // 4.启动一个协程
123 |     go [&]{
124 |         // 5.构造RPC调用参数
125 |         EchoRequest request;
126 |         request.set_code(1);
127 | 
128 |         // 6.调用RPC接口
129 |         std::shared_ptr<EchoResponse> rsp = stub.Echo(request);
130 | 
131 |         // 7.获取返回值
132 |         std::cout << "Response: " << rsp->code() << endl;
133 |     };
134 | 
135 |     // 8.启动协程框架主循环
136 |     co_sched.RunLoop();
137 |     return 0;
138 | }
139 |   ~~~~~~~~~~
140 |   
141 | ## 高级用法
142 | ucorf的高级用法请参见samples目录下的一些示例.
143 |   
144 | 


--------------------------------------------------------------------------------
/ucorf/logger.cpp:
--------------------------------------------------------------------------------
  1 | #include "logger.h"
  2 | #include <chrono>
  3 | #include <ctime>
  4 | #include <time.h>
  5 | #include <iomanip>
  6 | #include <sstream>
  7 | #include <boost/thread.hpp>
  8 | #include <stdarg.h>
  9 | 
 10 | namespace ucorf
 11 | {
 12 |     static const char* eLogLevelName[] =
 13 |     {
 14 |         "VERB",
 15 |         "DEBUG",
 16 |         "INFO",
 17 |         "NOTICE",
 18 |         "WARN",
 19 |         "ERROR",
 20 |         "FATAL",
 21 |     };
 22 | 
 23 |     Logger& Logger::default_instance()
 24 |     {
 25 |         static Logger lg;
 26 |         return lg;
 27 |     }
 28 | 
 29 |     Logger::~Logger()
 30 |     {
 31 |         if (file_ && file_ != stdout && file_ != stderr)
 32 |             std::fclose(file_);
 33 |     }
 34 | 
 35 |     bool Logger::Reopen(std::string destination)
 36 |     {
 37 |         std::FILE* file = std::fopen(destination.c_str(), "a+");
 38 |         if (!file) return false;
 39 | 
 40 |         std::unique_lock<co_wmutex> lock(rw_mtx_.writer());
 41 | 
 42 |         if (file_ != stdout && file_ != stderr)
 43 |             std::fclose(file_);
 44 | 
 45 |         file_ = file;
 46 |         destination_ = destination;
 47 |         return true;
 48 |     }
 49 | 
 50 |     void Logger::SetLevel(eLogLevel level)
 51 |     {
 52 |         level_ = level;
 53 |     }
 54 | 
 55 |     void Logger::SetMask(size_t mask)
 56 |     {
 57 |         mask_ = mask;
 58 |     }
 59 | 
 60 |     void Logger::Write(eLogLevel level, const char* file,
 61 |             int line, const char* func,
 62 |             const char* fmt, ...)
 63 |     {
 64 |         if (!file_) return ;
 65 | 
 66 |         level = std::max(std::min(eLogLevel::fatal, level), eLogLevel::verbose);
 67 | 
 68 |         std::ostringstream info;
 69 |         if (mask_ & (size_t)eLogFlag::time) {
 70 |             auto now = std::chrono::high_resolution_clock::now();
 71 |             std::time_t t = std::chrono::high_resolution_clock::to_time_t(now);
 72 |             tm m;
 73 |             localtime_r(&t, &m);
 74 |             char buf[128];
 75 |             snprintf(buf, sizeof(buf), "%d-%02d-%02d %02d:%02d:%02d.%03d",
 76 |                     1900 + m.tm_year, m.tm_mon, m.tm_mday, m.tm_hour, m.tm_min, m.tm_sec,
 77 |                     (int)(std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count() % 1000));
 78 |             info << buf << "|";
 79 |         }
 80 | 
 81 |         if (mask_ & (size_t)eLogFlag::tid) {
 82 |             info << "T:" << boost::this_thread::get_id() << "|";
 83 |         }
 84 | 
 85 |         info << eLogLevelName[(int)level] << "|";
 86 | 
 87 |         if (mask_ & (size_t)eLogFlag::file) {
 88 |             const char* p = strrchr(file, '/');
 89 |             if (!p) p = strrchr(file, '\\');
 90 | 
 91 |             if (p) ++p;
 92 |             else p = file;
 93 |             info << "F:" << p << "|";
 94 |         }
 95 | 
 96 |         if (mask_ & (size_t)eLogFlag::line) {
 97 |             info << "L:" << line << "|";
 98 |         }
 99 | 
100 |         if (mask_ & (size_t)eLogFlag::func) {
101 |             info << "(" << func << "): ";
102 |         }
103 | 
104 |         va_list args;
105 |         char buf[1024];
106 |         va_start(args, fmt);
107 |         int len = vsnprintf(buf, sizeof(buf), fmt, args);
108 |         if (len > (int)sizeof(buf)) {
109 |             char *b = new char[len + 1];
110 |             vsnprintf(b, len + 1, fmt, args);
111 |             info << b;
112 |             delete b;
113 |         } else {
114 |             info << buf;
115 |         }
116 | 
117 |         info << "\n";
118 |         std::string msg = info.str();
119 | 
120 |         std::unique_lock<co_rmutex> lock(rw_mtx_.reader());
121 |         if (!file_) return ;
122 | 
123 |         std::fwrite(msg.c_str(), msg.length(), 1, file_);
124 |         std::fflush(file_);
125 |     }
126 | 
127 | } //namespace ucorf
128 | 


--------------------------------------------------------------------------------
/test/wnd_client.cpp:
--------------------------------------------------------------------------------
  1 | #include <ucorf/client.h>
  2 | #include <ucorf/net_transport.h>
  3 | #include <ucorf/dispatcher.h>
  4 | #include <ucorf/server_finder.h>
  5 | #include "echo.rpc.h"
  6 | #include <iostream>
  7 | #include <cstdio>
  8 | #include <boost/smart_ptr/make_shared.hpp>
  9 | #include <boost/thread.hpp>
 10 | using std::cout;
 11 | using std::endl;
 12 | using namespace Echo;
 13 | 
 14 | static int concurrecy = 100;
 15 | static int thread_c = 2;
 16 | static std::atomic<size_t> g_count{0};
 17 | static std::atomic<size_t> g_error{0};
 18 | static int g_all_time{0};
 19 | static int g_max_time{0};
 20 | boost_ec last_ec;
 21 | 
 22 | void show_status()
 23 | {
 24 |     static int c = 0;
 25 |     if (c++ % 10 == 0) {
 26 |         std::printf("--------------------- Co: %5d  Thread: %d --------------------------\n", concurrecy, thread_c);
 27 |         std::printf("|   QPS   |  error  | average D | max D | Interval | last_error   \n");
 28 |     }
 29 | 
 30 |     static std::chrono::system_clock::time_point last_time = std::chrono::system_clock::now();
 31 |     auto now = std::chrono::system_clock::now();
 32 |     static size_t last_count = 0;
 33 |     static size_t last_error = 0;
 34 |     int qps = (int)(g_count - last_count);
 35 |     int err = (int)(g_error - last_error);
 36 |     std::string errinfo = last_ec.message();
 37 |     last_count = g_count;
 38 |     last_error = g_error;
 39 |     last_ec = boost_ec();
 40 | 
 41 |     std::printf("|%7d  |%7d  | %5d     |%5d  | %6d   | %s\n",
 42 |             qps, err, g_all_time / (qps + 1), g_max_time,
 43 |             (int)std::chrono::duration_cast<std::chrono::milliseconds>(now - last_time).count(),
 44 |             errinfo.c_str()
 45 |             );
 46 |     last_time = now;
 47 |     g_all_time = g_max_time = 0;
 48 | }
 49 | 
 50 | int main(int argc, char** argv)
 51 | {
 52 |     using namespace ucorf;
 53 | 
 54 |     if (argc > 1) {
 55 |         concurrecy = atoi(argv[1]);
 56 |     }
 57 | 
 58 |     if (argc > 2)
 59 |         thread_c = atoi(argv[2]);
 60 | 
 61 |     std::string url = "tcp://127.0.0.1:48080";
 62 |     if (argc > 3)
 63 |         url = argv[3];
 64 | 
 65 |     ::network::OptionsUser tp_opt;
 66 |     tp_opt.max_pack_size_ = 40960;
 67 |     auto opt = boost::make_shared<Option>();
 68 |     opt->transport_opt = tp_opt;
 69 |     opt->rcv_timeout_ms = 0;
 70 |     opt->request_wnd_size = 100;
 71 | 
 72 |     Client client;
 73 |     client.SetOption(opt).SetUrl(url);
 74 |     for (int i = 0; i < thread_c; ++i)
 75 |         client.SetServerFinder(std::unique_ptr<ServerFinder>(new ServerFinder));
 76 | 
 77 |     UcorfEchoServiceStub stub(&client);
 78 | 
 79 |     for (int i = 0; i < concurrecy; ++i)
 80 |         go [&]{
 81 |             for (;;) {
 82 |                 EchoRequest request;
 83 |                 request.set_code(1);
 84 |                 EchoResponse response;
 85 | 
 86 |                 auto now = std::chrono::system_clock::now();
 87 |                 boost_ec ec = stub.Echo(request, &response);
 88 |                 if (ec) {
 89 |                     co_yield;
 90 |                     ++g_error;
 91 |                     last_ec = ec;
 92 | //                    cout << "rpc call error: " << ec.message() << endl;
 93 |                 } else {
 94 |                     ++g_count;
 95 |                     int delay = (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - now).count();
 96 |                     g_all_time += delay;
 97 |                     if (g_max_time < delay)
 98 |                         g_max_time = delay;
 99 |                 }
100 |             }
101 |         };
102 | 
103 |     go []{
104 |         for (;;) {
105 |             show_status();
106 |             co_sleep(1000);
107 |         }
108 |     };
109 | 
110 |     boost::thread_group tg;
111 |     for (int i = 0; i < thread_c; ++i)
112 |         tg.create_thread([]{ co_sched.RunLoop(); });
113 |     tg.join_all();
114 |     return 0;
115 | }
116 | 


--------------------------------------------------------------------------------
/test/hprose_bmclient.cpp:
--------------------------------------------------------------------------------
  1 | #include <ucorf/client.h>
  2 | #include <ucorf/net_transport.h>
  3 | #include <ucorf/dispatcher.h>
  4 | #include <ucorf/server_finder.h>
  5 | #include <ucorf/hprose/hprose_service.h>
  6 | #include <iostream>
  7 | #include <cstdio>
  8 | #include <boost/smart_ptr/make_shared.hpp>
  9 | #include <boost/thread.hpp>
 10 | using std::cout;
 11 | using std::endl;
 12 | using namespace ucorf;
 13 | using namespace ucorf::hprose;
 14 | 
 15 | static int concurrecy = 256;
 16 | static int thread_c = 1;
 17 | static int connection_c = 1;
 18 | static std::atomic<size_t> g_count{0};
 19 | static std::atomic<size_t> g_error{0};
 20 | static int g_all_time{0};
 21 | static int g_max_time{0};
 22 | boost_ec last_ec;
 23 | struct itimerval g_itimer;
 24 | 
 25 | void show_status()
 26 | {
 27 |     static int c = 0;
 28 |     if (c++ % 10 == 0) {
 29 |         std::printf("---------------- Co: %5d  Thread: %d Conn: %d --------------------\n", concurrecy, thread_c, connection_c);
 30 |         std::printf("|   QPS   |  error  | average D | max D | Interval | last_error   \n");
 31 |     }
 32 | 
 33 |     static std::chrono::system_clock::time_point last_time = std::chrono::system_clock::now();
 34 |     auto now = std::chrono::system_clock::now();
 35 |     static size_t last_count = 0;
 36 |     static size_t last_error = 0;
 37 |     int qps = (int)(g_count - last_count);
 38 |     int err = (int)(g_error - last_error);
 39 |     std::string errinfo = last_ec.message();
 40 |     last_count = g_count;
 41 |     last_error = g_error;
 42 |     last_ec = boost_ec();
 43 | 
 44 |     std::printf("|%7d  |%7d  | %5d     |%5d  | %6d   | %s\n",
 45 |             qps, err, g_all_time / (qps + 1), g_max_time,
 46 |             (int)std::chrono::duration_cast<std::chrono::milliseconds>(now - last_time).count(),
 47 |             errinfo.c_str()
 48 |             );
 49 |     last_time = now;
 50 |     g_all_time = g_max_time = 0;
 51 | }
 52 | 
 53 | int main(int argc, char** argv)
 54 | {
 55 |     getitimer(ITIMER_PROF, &g_itimer);
 56 | 
 57 |     if (argc > 1 && std::string(argv[1]) == "-h") {
 58 |         printf("Usage: hprose_bmclient.t [Coroutines] [ThreadCount] [Connections] [Address]\n");
 59 |         return 0;
 60 |     }
 61 | 
 62 |     if (argc > 1) {
 63 |         concurrecy = atoi(argv[1]);
 64 |     }
 65 | 
 66 |     if (argc > 2)
 67 |         thread_c = atoi(argv[2]);
 68 | 
 69 |     if (argc > 3)
 70 |         connection_c = atoi(argv[3]);
 71 | 
 72 |     std::string url = "tcp://127.0.0.1:48080";
 73 |     if (argc > 4)
 74 |         url = argv[4];
 75 | 
 76 | //    FILE * lg = fopen("log", "a+");
 77 | //    if (!lg) {
 78 | //        cout << "open log error:" << strerror(errno) << endl;
 79 | //        return 1;
 80 | //    }
 81 | //
 82 | //    co_sched.GetOptions().debug_output = lg;
 83 | //    co_sched.GetOptions().debug = co::dbg_all;
 84 | 
 85 |     ::network::OptionsUser tp_opt;
 86 |     tp_opt.max_pack_size_ = 40960;
 87 |     auto opt = boost::make_shared<Option>();
 88 |     opt->transport_opt = tp_opt;
 89 |     opt->rcv_timeout_ms = 0;
 90 | 
 91 |     Client client;
 92 |     for (int i = 0; i < connection_c; ++i)
 93 |         client.SetServerFinder(std::unique_ptr<ServerFinder>(new ServerFinder));
 94 |     client.SetOption(opt).SetUrl(url);
 95 |     client.SetHeaderFactory(&Hprose_Head::Factory);
 96 |     Hprose_ServiceStub stub(&client);
 97 | 
 98 |     for (int i = 0; i < concurrecy; ++i)
 99 |         go [&]{
100 |             for (;;) {
101 |                 auto now = std::chrono::system_clock::now();
102 |                 boost_ec ec;
103 |                 int rsp = stub.CallMethod<int>("add", ec, 1);
104 |                 if (ec) {
105 |                     co_sleep(1);
106 |                     ++g_error;
107 |                     last_ec = ec;
108 | //                    cout << "rpc call error: " << ec.message() << endl;
109 |                 } else {
110 |                     ++g_count;
111 |                     co_yield;
112 |                     int delay = (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - now).count();
113 |                     g_all_time += delay;
114 |                     if (g_max_time < delay)
115 |                         g_max_time = delay;
116 |                 }
117 |             }
118 |         };
119 | 
120 |     go []{
121 |         for (;;) {
122 |             show_status();
123 |             co_sleep(1000);
124 |         }
125 |     };
126 | 
127 | //    go []{
128 | //        co_sleep(10000);
129 | //        exit(0);
130 | //    };
131 | 
132 |     if (thread_c > 1) {
133 |         boost::thread_group tg;
134 |         for (int i = 0; i < thread_c; ++i)
135 |             tg.create_thread([]{
136 |                     setitimer(ITIMER_PROF, &g_itimer, NULL);
137 |                     co_sched.RunLoop();
138 |                 });
139 |         tg.join_all();
140 |     } else {
141 |         co_sched.RunUntilNoTask();
142 |     }
143 |     return 0;
144 | }
145 | 


--------------------------------------------------------------------------------
/test/bmclient.cpp:
--------------------------------------------------------------------------------
  1 | #include <ucorf/client.h>
  2 | #include <ucorf/net_transport.h>
  3 | #include <ucorf/dispatcher.h>
  4 | #include <ucorf/server_finder.h>
  5 | #include "echo.rpc.h"
  6 | #include <iostream>
  7 | #include <cstdio>
  8 | #include <boost/smart_ptr/make_shared.hpp>
  9 | #include <boost/thread.hpp>
 10 | using std::cout;
 11 | using std::endl;
 12 | using namespace Echo;
 13 | 
 14 | static int concurrecy = 256;
 15 | static int thread_c = 1;
 16 | static int connection_c = 1;
 17 | static std::atomic<size_t> g_count{0};
 18 | static std::atomic<size_t> g_error{0};
 19 | static int g_all_time{0};
 20 | static int g_max_time{0};
 21 | boost_ec last_ec;
 22 | struct itimerval g_itimer;
 23 | 
 24 | void show_status()
 25 | {
 26 |     static int c = 0;
 27 |     if (c++ % 10 == 0) {
 28 |         std::printf("---------------- Co: %5d  Thread: %d Conn: %d --------------------\n", concurrecy, thread_c, connection_c);
 29 |         std::printf("|   QPS   |  error  | average D | max D | Interval | last_error   \n");
 30 |     }
 31 | 
 32 |     static std::chrono::system_clock::time_point last_time = std::chrono::system_clock::now();
 33 |     auto now = std::chrono::system_clock::now();
 34 |     static size_t last_count = 0;
 35 |     static size_t last_error = 0;
 36 |     int qps = (int)(g_count - last_count);
 37 |     int err = (int)(g_error - last_error);
 38 |     std::string errinfo = last_ec.message();
 39 |     last_count = g_count;
 40 |     last_error = g_error;
 41 |     last_ec = boost_ec();
 42 | 
 43 |     std::printf("|%7d  |%7d  | %5d     |%5d  | %6d   | %s\n",
 44 |             qps, err, g_all_time / (qps + 1), g_max_time,
 45 |             (int)std::chrono::duration_cast<std::chrono::milliseconds>(now - last_time).count(),
 46 |             errinfo.c_str()
 47 |             );
 48 |     last_time = now;
 49 |     g_all_time = g_max_time = 0;
 50 | }
 51 | 
 52 | int main(int argc, char** argv)
 53 | {
 54 |     using namespace ucorf;
 55 |     getitimer(ITIMER_PROF, &g_itimer);
 56 | 
 57 |     if (argc > 1 && std::string(argv[1]) == "-h") {
 58 |         printf("Usage: bmclient.t [Coroutines] [ThreadCount] [Connections] [Address]\n");
 59 |         return 0;
 60 |     }
 61 | 
 62 |     if (argc > 1) {
 63 |         concurrecy = atoi(argv[1]);
 64 |     }
 65 | 
 66 |     if (argc > 2)
 67 |         thread_c = atoi(argv[2]);
 68 | 
 69 |     if (argc > 3)
 70 |         connection_c = atoi(argv[3]);
 71 | 
 72 |     std::string url = "tcp://127.0.0.1:48080";
 73 |     if (argc > 4)
 74 |         url = argv[4];
 75 | 
 76 | //    FILE * lg = fopen("log", "a+");
 77 | //    if (!lg) {
 78 | //        cout << "open log error:" << strerror(errno) << endl;
 79 | //        return 1;
 80 | //    }
 81 | //
 82 | //    co_sched.GetOptions().debug_output = lg;
 83 | //    co_sched.GetOptions().debug = co::dbg_all;
 84 | 
 85 |     ::network::OptionsUser tp_opt;
 86 |     tp_opt.max_pack_size_ = 40960;
 87 |     auto opt = boost::make_shared<Option>();
 88 |     opt->transport_opt = tp_opt;
 89 |     opt->rcv_timeout_ms = 0;
 90 | 
 91 |     Client client;
 92 |     for (int i = 0; i < connection_c; ++i)
 93 |         client.SetServerFinder(std::unique_ptr<ServerFinder>(new ServerFinder));
 94 |     client.SetOption(opt).SetUrl(url);
 95 |     
 96 |     UcorfEchoServiceStub stub(&client);
 97 | 
 98 |     for (int i = 0; i < concurrecy; ++i)
 99 |         go [&]{
100 |             EchoRequest request;
101 |             request.set_code(1);
102 |             EchoResponse response;
103 | 
104 |             for (;;) {
105 |                 auto now = std::chrono::system_clock::now();
106 | //                boost_ec ec = stub.Echo(request, (EchoResponse*)nullptr);
107 |                 boost_ec ec = stub.Echo(request, &response);
108 |                 if (ec) {
109 |                     co_sleep(1);
110 |                     ++g_error;
111 |                     last_ec = ec;
112 | //                    cout << "rpc call error: " << ec.message() << endl;
113 |                 } else {
114 |                     ++g_count;
115 |                     co_yield;
116 |                     int delay = (int)std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - now).count();
117 |                     g_all_time += delay;
118 |                     if (g_max_time < delay)
119 |                         g_max_time = delay;
120 |                 }
121 |             }
122 |         };
123 | 
124 |     go []{
125 |         for (;;) {
126 |             show_status();
127 |             co_sleep(1000);
128 |         }
129 |     };
130 | 
131 |     go []{
132 |         co_sleep(10000);
133 |         exit(0);
134 |     };
135 | 
136 |     if (thread_c > 1) {
137 |         boost::thread_group tg;
138 |         for (int i = 0; i < thread_c; ++i)
139 |             tg.create_thread([]{
140 |                     setitimer(ITIMER_PROF, &g_itimer, NULL);
141 |                     co_sched.RunLoop();
142 |                 });
143 |         tg.join_all();
144 |     } else {
145 |         co_sched.RunUntilNoTask();
146 |     }
147 |     return 0;
148 | }
149 | 


--------------------------------------------------------------------------------
/ucorf/net_transport.cpp:
--------------------------------------------------------------------------------
  1 | #include "net_transport.h"
  2 | #include "logger.h"
  3 | 
  4 | namespace ucorf
  5 | {
  6 |     // server
  7 |     NetTransportServer::NetTransportServer()
  8 |     {
  9 |         ucorf_log_debug("NetTransportServer construct.");
 10 |     }
 11 |     NetTransportServer::~NetTransportServer()
 12 |     {
 13 |         ucorf_log_debug("NetTransportServer destruct.");
 14 |     }
 15 | 
 16 |     void NetTransportServer::Shutdown()
 17 |     {
 18 |         s_.Shutdown();
 19 |     }
 20 |     void NetTransportServer::SetReceiveCb(OnReceiveF const& cb)
 21 |     {
 22 |         s_.SetReceiveCb([=](::network::SessionEntry sess, const char* data, size_t bytes)
 23 |                 {
 24 |                     return cb(boost::any(sess), data, bytes);
 25 |                 });
 26 |     }
 27 |     void NetTransportServer::SetConnectedCb(OnConnectedF const& cb)
 28 |     {
 29 |         s_.SetConnectedCb([=](::network::SessionEntry sess)
 30 |                 {
 31 |                     ucorf_log_debug("new connection");
 32 |                     cb(boost::any(sess));
 33 |                 });
 34 |     }
 35 |     void NetTransportServer::SetDisconnectedCb(OnDisconnectedF const& cb)
 36 |     {
 37 |         s_.SetDisconnectedCb([=](::network::SessionEntry sess, ::network::boost_ec const& ec)
 38 |                 {
 39 |                     ucorf_log_debug("connection disconnect: %s", ec.message().c_str());
 40 |                     cb(boost::any(sess), ec);
 41 |                 });
 42 |     }
 43 | 
 44 |     void NetTransportServer::SetOption(boost::any const& opt)
 45 |     {
 46 |         ::network::OptionsUser net_opt;
 47 |         if (opt.empty()) {
 48 |             net_opt.max_pack_size_ = 64 * 1024;
 49 |             return ;
 50 |         }
 51 |         net_opt = boost::any_cast<::network::OptionsUser const&>(opt);
 52 |         s_.SetSndTimeout(net_opt.sndtimeo_);
 53 |         s_.SetMaxPackSize(net_opt.max_pack_size_);
 54 |     }
 55 | 
 56 |     boost_ec NetTransportServer::Listen(std::string const& url)
 57 |     {
 58 |         url_ = url;
 59 |         return s_.goStart(url);
 60 |     }
 61 |     void NetTransportServer::Send(SessId id, const void* data, size_t bytes, OnSndF const& cb)
 62 |     {
 63 |         ::network::SessionEntry &sess = ::boost::any_cast<::network::SessionEntry&>(id);
 64 |         sess->Send(data, bytes, cb);
 65 |     }
 66 |     void NetTransportServer::Send(SessId id, std::vector<char> && buf, OnSndF const& cb)
 67 |     {
 68 |         ::network::SessionEntry &sess = ::boost::any_cast<::network::SessionEntry&>(id);
 69 |         sess->Send(std::move(buf), cb);
 70 |     }
 71 |     std::string NetTransportServer::LocalUrl() const
 72 |     {
 73 |         return url_;
 74 |     }
 75 | 
 76 |     // client
 77 |     NetTransportClient::NetTransportClient()
 78 |     {
 79 |         ucorf_log_debug("NetTransportClient construct.");
 80 |     }
 81 |     NetTransportClient::~NetTransportClient()
 82 |     {
 83 |         ucorf_log_debug("NetTransportClient destruct.");
 84 |     }
 85 | 
 86 |     void NetTransportClient::Shutdown()
 87 |     {
 88 |         c_.Shutdown();
 89 |     }
 90 |     void NetTransportClient::SetReceiveCb(OnReceiveF const& cb)
 91 |     {
 92 |         c_.SetReceiveCb([=](::network::SessionEntry sess, const char* data, size_t bytes)
 93 |                 {
 94 |                     return cb(boost::any(sess), data, bytes);
 95 |                 });
 96 |     }
 97 |     void NetTransportClient::SetConnectedCb(OnConnectedF const& cb)
 98 |     {
 99 |         c_.SetConnectedCb([=](::network::SessionEntry sess)
100 |                 {
101 |                     ucorf_log_debug("connect sucess");
102 |                     cb(boost::any(sess));
103 |                 });
104 |     }
105 |     void NetTransportClient::SetDisconnectedCb(OnDisconnectedF const& cb)
106 |     {
107 |         c_.SetDisconnectedCb([=](::network::SessionEntry sess, ::network::boost_ec const& ec)
108 |                 {
109 |                     ucorf_log_debug("disconnect because: %s", ec.message().c_str());
110 |                     cb(boost::any(sess), ec);
111 |                 });
112 |     }
113 |     void NetTransportClient::SetOption(boost::any const& opt)
114 |     {
115 |         ::network::OptionsUser net_opt;
116 |         if (opt.empty()) {
117 |             net_opt.max_pack_size_ = 64 * 1024;
118 |             return ;
119 |         }
120 |         net_opt = boost::any_cast<::network::OptionsUser const&>(opt);
121 |         c_.SetSndTimeout(net_opt.sndtimeo_);
122 |         c_.SetMaxPackSize(net_opt.max_pack_size_);
123 |     }
124 | 
125 |     boost_ec NetTransportClient::Connect(std::string const& url)
126 |     {
127 |         url_ = url;
128 |         return c_.Connect(url);
129 |     }
130 |     void NetTransportClient::Send(const void* data, size_t bytes, OnSndF const& cb)
131 |     {
132 |         c_.Send(data, bytes, cb);
133 |     }
134 |     void NetTransportClient::Send(std::vector<char> && buf, OnSndF const& cb)
135 |     {
136 |         c_.Send(std::move(buf), cb);
137 |     }
138 |     bool NetTransportClient::IsEstab()
139 |     {
140 |         return c_.IsEstab();
141 |     }
142 |     std::string NetTransportClient::RemoteUrl() const
143 |     {
144 |         return url_;
145 |     }
146 | 
147 | } //namespace ucorf
148 | 


--------------------------------------------------------------------------------
/ucorf/server_impl.cpp:
--------------------------------------------------------------------------------
  1 | #include "server_impl.h"
  2 | #include "message.h"
  3 | #include "service.h"
  4 | #include "logger.h"
  5 | #include "zookeeper.h"
  6 | #include <boost/algorithm/string.hpp>
  7 | #include "net_transport.h"
  8 | 
  9 | namespace ucorf
 10 | {
 11 |     ServerImpl::ServerImpl()
 12 |         : opt_(new Option), register_(new ZookeeperRegister),
 13 |         head_factory_(&UcorfHead::Factory)
 14 |     {
 15 |     }
 16 | 
 17 |     ServerImpl::~ServerImpl()
 18 |     {
 19 |         register_->Unregister();
 20 |     }
 21 | 
 22 |     ServerImpl& ServerImpl::BindTransport(std::unique_ptr<ITransportServer> && transport)
 23 |     {
 24 |         if (!opt_->transport_opt.empty())
 25 |             transport->SetOption(opt_->transport_opt);
 26 | 
 27 |         transport->SetReceiveCb(boost::bind(&ServerImpl::OnReceiveData,
 28 |                     this, transport.get(), _1, _2, _3));
 29 |         transport->SetConnectedCb(boost::bind(&ServerImpl::OnConnected,
 30 |                     this, transport.get(), _1));
 31 |         transport->SetDisconnectedCb(boost::bind(&ServerImpl::OnDisconnected,
 32 |                     this, transport.get(), _1, _2));
 33 |         transports_.push_back(std::move(transport));
 34 |         return *this;
 35 |     }
 36 | 
 37 |     ServerImpl& ServerImpl::SetOption(boost::shared_ptr<Option> opt)
 38 |     {
 39 |         opt_ = opt;
 40 |         for (auto &p:transports_)
 41 |             p->SetOption(opt_);
 42 |         return *this;
 43 |     }
 44 | 
 45 |     ServerImpl& ServerImpl::SetHeaderFactory(HeaderFactory const& head_factory)
 46 |     {
 47 |         head_factory_ = head_factory;
 48 |         return *this;
 49 |     }
 50 | 
 51 |     ServerImpl& ServerImpl::SetRegister(boost::shared_ptr<IServerRegister> reg)
 52 |     {
 53 |         register_->Unregister();
 54 |         register_ = reg;
 55 |         return *this;
 56 |     }
 57 | 
 58 |     bool ServerImpl::RegisterTo(std::string const& url)
 59 |     {
 60 |         for (auto &tp : transports_) {
 61 |             std::string addr = tp->LocalUrl();
 62 |             if (!register_->Register(url, addr))
 63 |                 return false;
 64 |         }
 65 | 
 66 |         return true;
 67 |     }
 68 | 
 69 |     bool ServerImpl::RegisterService(boost::shared_ptr<IService> service)
 70 |     {
 71 |         std::string name = service->name();
 72 |         return services_.insert(std::make_pair(name, service)).second;
 73 |     }
 74 | 
 75 |     void ServerImpl::RemoveService(std::string const& service_name)
 76 |     {
 77 |         services_.erase(service_name);
 78 |     }
 79 | 
 80 |     boost_ec ServerImpl::Listen(std::string const& url)
 81 |     {
 82 |         std::unique_ptr<ITransportServer> tp(new NetTransportServer);
 83 |         boost_ec ec = tp->Listen(url);
 84 |         if (ec) return ec;
 85 |         BindTransport(std::move(tp));
 86 |         return boost_ec();
 87 |     }
 88 | 
 89 |     void ServerImpl::OnConnected(ITransportServer *tp, SessId sess_id)
 90 |     {
 91 |         (void)tp;
 92 |         (void)sess_id;
 93 |     }
 94 |     void ServerImpl::OnDisconnected(ITransportServer *tp, SessId sess_id, boost_ec const& ec)
 95 |     {
 96 |         (void)tp;
 97 |         (void)sess_id;
 98 |         (void)ec;
 99 |     }
100 | 
101 |     size_t ServerImpl::OnReceiveData(ITransportServer *tp, SessId sess_id, const char* data, size_t bytes)
102 |     {
103 |         size_t consume = 0;
104 |         const char* buf = data;
105 |         size_t len = bytes;
106 | 
107 |         int yield_c = 0;
108 |         while (consume < bytes)
109 |         {
110 |             IHeaderPtr header = head_factory_();
111 |             size_t head_len = header->Parse(buf, len);
112 |             if (!head_len) break;
113 | 
114 |             size_t follow_bytes = header->GetFollowBytes();
115 |             if (head_len + follow_bytes > len) break;
116 | 
117 |             Session sess = {sess_id, tp, header};
118 |             if (!DispatchMsg(sess, buf + head_len, follow_bytes))
119 |                 return -1;
120 | 
121 |             consume += head_len + follow_bytes;
122 |             buf = data + consume;
123 |             len = bytes - consume;
124 | 
125 |             if ((++yield_c & 0xff) == 0)
126 |                 co_yield;
127 |         }
128 | 
129 |         if (yield_c <= 0xff)
130 |             co_yield;
131 |         return consume;
132 |     }
133 | 
134 |     bool ServerImpl::DispatchMsg(Session & sess, const char* data, size_t bytes)
135 |     {
136 |         std::string const& srv_name = sess.header->GetService();
137 |         auto it = services_.find(srv_name);
138 |         if (services_.end() == it) return false;
139 | 
140 |         auto &service = it->second;
141 |         std::unique_ptr<IMessage> response(service->CallMethod(sess.header->GetMethod(), data, bytes));
142 |         if (!response) return true;
143 | 
144 |         // reply
145 |         if (sess.header->GetType() != eHeaderType::oneway_request) {
146 |             sess.header->SetType(eHeaderType::response);
147 |             sess.header->SetFollowBytes(response->ByteSize());
148 |             std::vector<char> buf;
149 |             buf.resize(sess.header->ByteSize() + response->ByteSize());
150 |             sess.header->Serialize(&buf[0], sess.header->ByteSize());
151 |             if (!response->Serialize(&buf[sess.header->ByteSize()], response->ByteSize())) {
152 |                 ucorf_log_warn("response serialize error. srv=%s, method=%s, msgid=%llu",
153 |                         sess.header->GetService().c_str(), sess.header->GetMethod().c_str(),
154 |                         (unsigned long long)sess.header->GetId());
155 |                 return true;
156 |             }
157 | 
158 |             sess.transport->Send(sess.sess, std::move(buf), [sess](boost_ec const& ec) {
159 |                     if (ec)
160 |                         ucorf_log_warn("response send error: %s. srv=%s, method=%s, msgid=%llu",
161 |                             ec.message().c_str(), sess.header->GetService().c_str(),
162 |                             sess.header->GetMethod().c_str(), (unsigned long long)sess.header->GetId());
163 |                     });
164 |         }
165 | 
166 |         return true;
167 |     }
168 | 
169 | } //namespace ucorf
170 | 


--------------------------------------------------------------------------------
/ucorf/server_finder.cpp:
--------------------------------------------------------------------------------
  1 | #include "server_finder.h"
  2 | #include <boost/algorithm/string.hpp>
  3 | #include <boost/weak_ptr.hpp>
  4 | #include "error.h"
  5 | #include "logger.h"
  6 | 
  7 | namespace ucorf
  8 | {
  9 |     ServerFinder::ServerFinder()
 10 |         : opt_(new Option), destroy_mutex_(new co_mutex), token_(new bool(true))
 11 |     {}
 12 | 
 13 |     ServerFinder::~ServerFinder()
 14 |     {
 15 |         std::unique_lock<co_mutex> lock(*destroy_mutex_);
 16 |         *token_ = false;
 17 |         if (!zk_addr_.empty()) {
 18 |             auto zk = ZookeeperClientMgr::getInstance().GetZookeeperClient(zk_addr_);
 19 |             zk->Unwatch(zk_path_, this);
 20 |         }
 21 |     }
 22 | 
 23 |     void ServerFinder::Init(std::string const& url, TransportFactory const& factory)
 24 |     {
 25 |         tp_factory_ = factory;
 26 |         url_ = url;
 27 | 
 28 |         if (boost::istarts_with(url_, "zk://")) {
 29 |             auto addr_path = ZookeeperClientMgr::getInstance().ParseZookeeperUrl(url_);
 30 |             if (addr_path.first.empty()) {
 31 |                 ucorf_log_error("zookeeper(%s) url parse error!", url_.c_str());
 32 |                 return ;
 33 |             }
 34 | 
 35 |             auto zk = ZookeeperClientMgr::getInstance().GetZookeeperClient(addr_path.first);
 36 |             zk->Watch(addr_path.second, boost::bind(&ServerFinder::OnZookeeperChilds, this, _1, token_, destroy_mutex_), this);
 37 |             mode_ = eMode::zk;
 38 |             return ;
 39 |         }
 40 | 
 41 |         // single connection.
 42 |         mode_ = eMode::single;
 43 |         single_tp_.reset(tp_factory_());
 44 |         if (!opt_->transport_opt.empty())
 45 |             single_tp_->SetOption(opt_->transport_opt);
 46 |         boost::weak_ptr<ITransportClient> weak(single_tp_);
 47 |         single_tp_->SetConnectedCb([=](SessId id){ on_connect_(weak.lock(), id); });
 48 |         single_tp_->SetReceiveCb([=](SessId id, const char* data, size_t len){ return on_receive_(weak.lock(), id, data, len); });
 49 |         single_tp_->SetDisconnectedCb(boost::bind(&ServerFinder::OnDisconnected, this, weak, _1, _2, url, token_, destroy_mutex_));
 50 |         go [=]{ ReConnect(); };
 51 |     }
 52 | 
 53 |     void ServerFinder::SetConnectedCb(OnConnectedF const& cb)
 54 |     {
 55 |         on_connect_ = cb;
 56 |     }
 57 | 
 58 |     void ServerFinder::SetReceiveCb(OnReceiveF const& cb)
 59 |     {
 60 |         on_receive_ = cb;
 61 |     }
 62 | 
 63 |     void ServerFinder::SetDisconnectedCb(OnDisconnectedF const& cb)
 64 |     {
 65 |         on_disconnect_ = cb;
 66 |     }
 67 | 
 68 |     void ServerFinder::SetOption(boost::shared_ptr<Option> opt)
 69 |     {
 70 |         opt_ = opt;
 71 |     }
 72 | 
 73 |     boost_ec ServerFinder::ReConnect()
 74 |     {
 75 |         if (mode_ == eMode::zk) {
 76 |             return MakeUcorfErrorCode(eUcorfErrorCode::ec_no_estab);
 77 |         } else if (mode_ == eMode::single) {
 78 |             if (!single_tp_->IsEstab())
 79 |                 return single_tp_->Connect(url_);
 80 | 
 81 |             return boost_ec();
 82 |         }
 83 | 
 84 |         return MakeUcorfErrorCode(eUcorfErrorCode::ec_unsupport_protocol);
 85 |     }
 86 | 
 87 |     void ServerFinder::OnZookeeperChilds(ZookeeperClient::Children const& nodes,
 88 |             boost::shared_ptr<bool> token, boost::shared_ptr<co_mutex> mutex)
 89 |     {
 90 |         std::unique_lock<co_mutex> lock(*mutex, std::defer_lock);
 91 |         if (!lock.try_lock()) return ;
 92 |         if (!*token) return ;
 93 | 
 94 |         TransportGroup tp_group;
 95 |         for (auto &node : nodes)
 96 |         {
 97 |             ucorf_log_debug(" zookeeper node: %s/%s", zk_path_.c_str(), node.c_str());
 98 |             std::string url = ZookeeperClientMgr::getInstance().ZookeeperNode2Url(node);
 99 |             if (transports_.count(url)) {
100 |                 tp_group[url].swap(transports_[url]);
101 |             } else {
102 |                 boost::shared_ptr<ITransportClient> tp(tp_factory_());
103 |                 tp_group[url] = tp;
104 |                 if (!opt_->transport_opt.empty())
105 |                     tp->SetOption(opt_->transport_opt);
106 |                 boost::weak_ptr<ITransportClient> weak(tp);
107 |                 tp->SetConnectedCb([=](SessId id){ on_connect_(weak.lock(), id); });
108 |                 tp->SetReceiveCb([=](SessId id, const char* data, size_t len){ return on_receive_(weak.lock(), id, data, len); });
109 |                 tp->SetDisconnectedCb(boost::bind(&ServerFinder::OnDisconnected, this, weak, _1, _2, url, token_, destroy_mutex_));
110 |                 go [=]{ RecursiveConnect(tp, url, token_, destroy_mutex_); };
111 |             }
112 |         }
113 | 
114 |         tp_group.swap(transports_);
115 | 
116 |         for (auto &kv : tp_group) {
117 |             auto &tp = kv.second;
118 |             if (!tp) continue;
119 | 
120 |             ucorf_log_warn("Node %s was miss on zookeeper.", tp->RemoteUrl().c_str());
121 |             tp->Shutdown();
122 |         }
123 |     }
124 | 
125 |     void ServerFinder::OnDisconnected(boost::weak_ptr<ITransportClient> weak,
126 |             SessId id, boost_ec const& ec, std::string url,
127 |             boost::shared_ptr<bool> token, boost::shared_ptr<co_mutex> mutex)
128 |     {
129 |         std::unique_lock<co_mutex> lock(*mutex, std::defer_lock);
130 |         if (!lock.try_lock()) return ;
131 |         if (!*token) return ;
132 | 
133 |         auto sptr = weak.lock();
134 |         if (!sptr) return ;
135 | 
136 |         if (mode_ == eMode::single || transports_.count(url))
137 |             go [=]{ RecursiveConnect(sptr, url, token, mutex); };
138 | 
139 |         if (on_disconnect_)
140 |             on_disconnect_(sptr, id, ec);
141 |     }
142 | 
143 |     void ServerFinder::RecursiveConnect(boost::shared_ptr<ITransportClient> sptr, std::string url,
144 |             boost::shared_ptr<bool> token, boost::shared_ptr<co_mutex> mutex)
145 |     {
146 |         boost_ec ec = sptr->Connect(url);
147 |         if (!ec) {
148 |             ucorf_log_debug("connect to %s success.", url.c_str());
149 |         } else {
150 |             ucorf_log_error("connect to %s error: %s.", url.c_str(), ec.message().c_str());
151 |             co_sleep(3000);
152 | 
153 |             if (sptr->IsEstab()) return ;
154 | 
155 |             {
156 |                 std::unique_lock<co_mutex> lock(*mutex, std::defer_lock);
157 |                 if (!lock.try_lock()) return ;
158 |                 if (!*token) return ;
159 |                 if (mode_ == eMode::zk && !transports_.count(url)) return ;
160 |             }
161 | 
162 |             go [=]{ RecursiveConnect(sptr, url, token, mutex); };
163 |         }
164 |     }
165 | 
166 | } //namespace ucorf
167 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_service.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "service.h"
  4 | #include "hprose_message.h"
  5 | #include "hprose_header.h"
  6 | #include "client.h"
  7 | #include "error.h"
  8 | #include "logger.h"
  9 | #include "hprose_protocol.h"
 10 | 
 11 | namespace ucorf {
 12 | namespace hprose {
 13 | 
 14 |     struct CalleeBase
 15 |     {
 16 |         virtual ~CalleeBase() {}
 17 |         virtual std::string Call(Buffer & reader) = 0;
 18 | 
 19 |         std::string R2Hprose(void)
 20 |         {
 21 |             Buffer buf;
 22 |             buf.Write(hprose::TagResult);
 23 |             buf.Write(hprose::TagEmpty);
 24 |             buf.Write(hprose::TagEnd);
 25 |             return buf.str();
 26 |         }
 27 | 
 28 |         template <typename R>
 29 |         std::string R2Hprose(R const& r)
 30 |         {
 31 |             Buffer buf;
 32 |             buf.Write(hprose::TagResult);
 33 |             buf.Write(r);
 34 |             buf.Write(hprose::TagEnd);
 35 |             return buf.str();
 36 |         }
 37 | 
 38 |         std::string error_arguments()
 39 |         {
 40 |             return "Es10\"Error Args\"z";
 41 |         }
 42 |     };
 43 | 
 44 |     template <typename F>
 45 |     struct Callee;
 46 | 
 47 |     template <typename R>
 48 |     struct Callee<R()> : public CalleeBase
 49 |     {
 50 |         typedef boost::function<R()> func_t;
 51 |         explicit Callee(func_t const& fn) : fn_(fn) {}
 52 | 
 53 |         virtual std::string Call(Buffer & reader) override
 54 |         {
 55 |             R result = fn_();
 56 |             return R2Hprose(result);
 57 |         }
 58 | 
 59 |         func_t fn_;
 60 |     };
 61 | 
 62 |     template <typename R, typename Arg>
 63 |     struct Callee<R(Arg)> : public CalleeBase
 64 |     {
 65 |         typedef boost::function<R(Arg)> func_t;
 66 |         explicit Callee(func_t const& fn) : fn_(fn) {}
 67 | 
 68 |         virtual std::string Call(Buffer & reader) override
 69 |         {
 70 |             Arg arg;
 71 |             if (reader.Read(arg)) {
 72 |                 R result = fn_(arg);
 73 |                 return R2Hprose(result);
 74 |             }
 75 | 
 76 |             return error_arguments();
 77 |         }
 78 | 
 79 |         func_t fn_;
 80 |     };
 81 | 
 82 |     template <typename R, typename Arg1, typename Arg2>
 83 |     struct Callee<R(Arg1, Arg2)> : public CalleeBase
 84 |     {
 85 |         typedef boost::function<R(Arg1, Arg2)> func_t;
 86 |         explicit Callee(func_t const& fn) : fn_(fn) {}
 87 | 
 88 |         virtual std::string Call(Buffer & reader) override
 89 |         {
 90 |             Arg1 arg1;
 91 |             Arg2 arg2;
 92 |             if (reader.Read(arg1) && reader.Read(arg2)) {
 93 |                 R result = fn_(arg1, arg2);
 94 |                 return R2Hprose(result);
 95 |             }
 96 | 
 97 |             return error_arguments();
 98 |         }
 99 | 
100 |         func_t fn_;
101 |     };
102 | 
103 |     template <typename R, typename Arg1, typename Arg2, typename Arg3>
104 |     struct Callee<R(Arg1, Arg2, Arg3)> : public CalleeBase
105 |     {
106 |         typedef boost::function<R(Arg1, Arg2, Arg3)> func_t;
107 |         explicit Callee(func_t const& fn) : fn_(fn) {}
108 | 
109 |         virtual std::string Call(Buffer & reader) override
110 |         {
111 |             Arg1 arg1;
112 |             Arg2 arg2;
113 |             Arg3 arg3;
114 |             if (reader.Read(arg1) && reader.Read(arg2) && reader.Read(arg3)) {
115 |                 R result = fn_(arg1, arg2, arg3);
116 |                 return R2Hprose(result);
117 |             }
118 | 
119 |             return error_arguments();
120 |         }
121 | 
122 |         func_t fn_;
123 |     };
124 | 
125 |     class Hprose_Service : public IService
126 |     {
127 |     public:
128 |         std::string name() override { return "hprose"; }
129 | 
130 |         template <typename R, typename ... Args>
131 |         bool RegisterFunction(std::string const& method, boost::function<R(Args)...> const& fn)
132 |         {
133 |             std::unique_lock<co_mutex> lock(func_mutex_);
134 |             return functions_.insert(std::make_pair(method,
135 |                         boost::static_pointer_cast<CalleeBase>(boost::make_shared<Callee<R(Args)...>>(fn))
136 |                         )).second;
137 |         }
138 | 
139 |         std::unique_ptr<IMessage> CallMethod(std::string const&,
140 |                 const char *request_data, size_t request_bytes) override;
141 | 
142 |     private:
143 |         std::string GetFunctionList();
144 | 
145 |         std::string Call(std::string const& method, Buffer & reader);
146 | 
147 |         co_mutex func_mutex_;
148 |         std::map<std::string, boost::shared_ptr<CalleeBase>> functions_;
149 |     };
150 | 
151 |     class Hprose_ServiceStub : public IServiceStub
152 |     {
153 |     public:
154 |         using IServiceStub::IServiceStub;
155 | 
156 |         std::string name() override { return "hprose"; }
157 | 
158 |         template <typename R, typename ... Args>
159 |         R CallMethod(std::string const& method, boost_ec & ec, Args && ... args)
160 |         {
161 |             Buffer buf;
162 |             buf.Write(hprose::TagCall);
163 |             buf.Write(method, true);
164 |             RecursiveWrite(buf, std::forward<Args>(args)...);
165 |             buf.Write(hprose::TagEnd);
166 | 
167 |             Hprose_Message request(buf.str());
168 |             Hprose_Message response;
169 |             ec = c_->Call("", "", &request, &response);
170 |             if (ec) return R();
171 | 
172 |             Buffer reader(response.body_);
173 |             char flag = reader.get();
174 |             if (flag == hprose::TagResult) {
175 |                 R r;
176 |                 if (reader.Read(r))
177 |                     return r;
178 |                 return R();
179 |             }
180 | 
181 |             if (flag == hprose::TagError) {
182 |                 std::string err;
183 |                 if (!reader.Read(err))
184 |                     err = "Parse Response Error";
185 |                 ucorf_log_error("returns error:%s", err.c_str());
186 |                 ec = MakeUcorfErrorCode(eUcorfErrorCode::ec_logic_error);
187 |                 return R();
188 |             }
189 | 
190 |             ucorf_log_error("request type error: 0x%x", (int)flag);
191 |             ec = MakeUcorfErrorCode(eUcorfErrorCode::ec_call_error);
192 |             return R();
193 |         }
194 | 
195 |         template <typename R, typename ... Args>
196 |         R CallMethodNE(std::string const& method, Args && ... args)
197 |         {
198 |             boost_ec ec;
199 |             return CallMethod(method, ec, std::forward<Args>(args)...);
200 |         }
201 | 
202 |         template <typename A, typename ... Args>
203 |         void RecursiveWrite(Buffer & buf, A && a)
204 |         {
205 |             buf.Write(a);
206 |         }
207 | 
208 |         template <typename A, typename ... Args>
209 |         void RecursiveWrite(Buffer & buf, A && a, Args && ... args)
210 |         {
211 |             buf.Write(std::forward<A>(a));
212 |             RecursiveWrite(buf, std::forward<Args>(args)...);
213 |         }
214 |     };
215 | 
216 | } //namespace hprose
217 | } //namespace ucorf
218 | 


--------------------------------------------------------------------------------
/proto_gen/protoc-gen-rpc:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | 
  3 | from descriptor_pb2 import *
  4 | from plugin_pb2 import *
  5 | import sys, os
  6 | 
  7 | def Log(s):
  8 |     f = open('log', 'a+')
  9 |     f.write('%s\n' % s)
 10 |     f.close()
 11 | 
 12 | #Log('-------------start-------------')
 13 | 
 14 | s = sys.stdin.read()
 15 | #Log('stdin %s bytes' % len(s))
 16 | 
 17 | gen_req = CodeGeneratorRequest()
 18 | gen_req.ParseFromString(s)
 19 | gen_rsp = CodeGeneratorResponse()
 20 | 
 21 | indent_content='    '
 22 | class C:
 23 |     def __init__(self):
 24 |         self.c = ''
 25 |         self.idt = 0
 26 | 
 27 |     def it(self):
 28 |         self.idt += 1
 29 |         return self
 30 | 
 31 |     def it_end(self):
 32 |         self.idt -= 1
 33 |         return self
 34 | 
 35 |     def out(self, info):
 36 |         self.c += info
 37 |         return self
 38 | 
 39 |     def outline(self, info = ''):
 40 |         if not info:
 41 |             self.c += '\n'
 42 |             return self
 43 | 
 44 |         self.c += indent_content * self.idt + info + '\n'
 45 |         return self
 46 | 
 47 |     def itf(self):
 48 |         return self.outline('{').it()
 49 | 
 50 |     def itf_end(self):
 51 |         return self.it_end().outline('}')
 52 | 
 53 | def Gen(filename, parameter):
 54 |     ori_filename = os.path.splitext(filename)[0]
 55 |     f = gen_rsp.file.add()
 56 | 
 57 |     ############### *.rpc.h ##############
 58 |     f.name = ori_filename + '.rpc.h'
 59 |     c = C()
 60 |     c.outline('#include <ucorf/pb_service.h>')
 61 |     c.outline('#include "%s.pb.h"' % ori_filename)
 62 |     c.outline()
 63 |     if parameter.package:
 64 |         c.out('namespace %s' % parameter.package)
 65 |     c.outline()
 66 |     c.outline('{')
 67 | 
 68 |     c.it()
 69 |     c.outline('using namespace ::google::protobuf;')
 70 |     c.outline('using namespace ::ucorf;')
 71 |     c.outline()
 72 |     # services
 73 |     for srv in parameter.service:
 74 |         srv_name = srv.name
 75 |         # Service
 76 |         c.outline('class Ucorf%s : public Pb_Service, private %s' % (srv_name, srv_name))
 77 |         c.outline('{')
 78 |         c.outline('public:')
 79 |         c.it()
 80 |         c.outline('virtual std::string name();')
 81 |         c.outline()
 82 |         c.outline('virtual bool Call(int method_idx, Message & request, Message & response);')
 83 |         c.outline()
 84 |         c.outline('virtual const ServiceDescriptor* GetDescriptor();')
 85 |         # methods
 86 |         for method in srv.method:
 87 |             m_name = method.name
 88 |             input_t = method.input_type.split('.')[-1]
 89 |             output_t = method.output_type.split('.')[-1]
 90 |             c.outline()
 91 |             c.outline('virtual bool %s(%s & request, %s & response) = 0;' % \
 92 |                 (m_name, input_t, output_t));
 93 |         c.it_end()
 94 |         c.outline('};')
 95 |         c.outline()
 96 |         # Stub
 97 |         c.outline('class Ucorf%sStub : public Pb_ServiceStub' % srv_name)
 98 |         c.outline('{')
 99 |         c.outline('public:')
100 |         c.it()
101 |         c.outline('explicit Ucorf%sStub(Client * c);' % srv_name)
102 |         c.outline()
103 |         c.outline('virtual std::string name();')
104 |         # methods
105 |         for method in srv.method:
106 |             m_name = method.name
107 |             input_t = method.input_type.split('.')[-1]
108 |             output_t = method.output_type.split('.')[-1]
109 |             c.outline()
110 |             c.outline('virtual std::shared_ptr<%s> %s(%s & request, boost_ec * ec = nullptr);' %\
111 |                     (output_t, m_name, input_t))
112 |             c.outline()
113 |             c.outline('virtual boost_ec %s(%s & request, %s * response);' %\
114 |                     (m_name, input_t, output_t))
115 |         c.it_end()
116 |         c.outline('};')
117 | 
118 |     c.it_end()
119 |     if parameter.package:
120 |         c.out('}')
121 |     c.outline()
122 |     f.content += c.c
123 | 
124 |     ############### *.rpc.cc ##############
125 |     f = gen_rsp.file.add()
126 |     f.name = ori_filename + '.rpc.cc'
127 |     c = C()
128 |     c.outline('#include "%s.rpc.h"' % ori_filename)
129 |     c.outline()
130 | 
131 |     if parameter.package:
132 |         c.out('namespace %s' % parameter.package)
133 |     c.outline()
134 |     c.outline('{')
135 |     c.it()
136 |     # services
137 |     for srv in parameter.service:
138 |         srv_name = srv.name
139 | 
140 |         c.outline('std::string Ucorf%s::name()' % srv_name).itf()
141 |         c.outline('return "%s";' % srv_name).itf_end().outline()
142 | 
143 |         c.outline('bool Ucorf%s::Call(int method_idx, Message & request, Message & response)' % srv_name).itf()
144 |         c.outline('switch (method_idx) {').it()
145 |         # methods
146 |         i = 0
147 |         for method in srv.method:
148 |             m_name = method.name
149 |             input_t = method.input_type.split('.')[-1]
150 |             output_t = method.output_type.split('.')[-1]
151 |             c.outline('case %s:' % i).it()
152 |             c.outline('return %s((%s &)request, (%s &)response);' % (m_name, input_t, output_t)).it_end()
153 |             i += 1
154 |         c.outline('default:').it()
155 |         c.outline('return false;').it_end()
156 |         c.it_end().outline('}')
157 |         c.itf_end().outline()
158 | 
159 |         c.outline('const ServiceDescriptor* Ucorf%s::GetDescriptor()' % srv_name)
160 |         c.itf().outline('return %s::GetDescriptor();' % srv_name)
161 |         c.itf_end().outline()
162 | 
163 |         c.outline('Ucorf%sStub::Ucorf%sStub(Client * c)' % (srv_name, srv_name))
164 |         c.it().outline(': Pb_ServiceStub(c) {}').it_end().outline()
165 | 
166 |         c.outline('std::string Ucorf%sStub::name()' % srv_name)
167 |         c.itf().outline('return "%s";' % srv_name).itf_end().outline()
168 | 
169 |         # methods
170 |         for method in srv.method:
171 |             m_name = method.name
172 |             input_t = method.input_type.split('.')[-1]
173 |             output_t = method.output_type.split('.')[-1]
174 |             c.outline('std::shared_ptr<%s> Ucorf%sStub::%s(%s & request, boost_ec * ec)' %\
175 |                     (output_t, srv_name, m_name, input_t))
176 |             c.itf()
177 |             c.outline('std::shared_ptr<%s> response = std::make_shared<%s>();' % (output_t, output_t))
178 |             c.outline('boost_ec e = CallMethod("%s", request, response.get());' % m_name)
179 |             c.outline('if (ec) {')
180 |             c.it().outline('if (e) *ec = e;').outline('else ec->clear();').it_end().outline('}')
181 |             c.outline().outline('return response;')
182 |             c.itf_end().outline()
183 | 
184 |             c.outline('boost_ec Ucorf%sStub::%s(%s & request, %s * response)' %\
185 |                     (srv_name, m_name, input_t, output_t))
186 |             c.itf().outline('return CallMethod("%s", request, response);' % m_name).itf_end().outline()
187 |     c.it_end()
188 |     if parameter.package:
189 |         c.out('}')
190 |     c.outline()
191 |     f.content += c.c
192 | 
193 | 
194 | for idx in range(len(gen_req.file_to_generate)):
195 |     Gen(gen_req.file_to_generate[idx], gen_req.proto_file[idx])
196 | 
197 | sys.stdout.write(gen_rsp.SerializeToString())
198 | 


--------------------------------------------------------------------------------
/proto_gen/plugin_pb2.py:
--------------------------------------------------------------------------------
  1 | # Generated by the protocol buffer compiler.  DO NOT EDIT!
  2 | # source: plugin.proto
  3 | 
  4 | from google.protobuf import descriptor as _descriptor
  5 | from google.protobuf import message as _message
  6 | from google.protobuf import reflection as _reflection
  7 | from google.protobuf import descriptor_pb2
  8 | # @@protoc_insertion_point(imports)
  9 | 
 10 | 
 11 | import descriptor_pb2
 12 | 
 13 | 
 14 | DESCRIPTOR = _descriptor.FileDescriptor(
 15 |   name='plugin.proto',
 16 |   package='google.protobuf.compiler',
 17 |   serialized_pb='\n\x0cplugin.proto\x12\x18google.protobuf.compiler\x1a\x10\x64\x65scriptor.proto\"}\n\x14\x43odeGeneratorRequest\x12\x18\n\x10\x66ile_to_generate\x18\x01 \x03(\t\x12\x11\n\tparameter\x18\x02 \x01(\t\x12\x38\n\nproto_file\x18\x0f \x03(\x0b\x32$.google.protobuf.FileDescriptorProto\"\xaa\x01\n\x15\x43odeGeneratorResponse\x12\r\n\x05\x65rror\x18\x01 \x01(\t\x12\x42\n\x04\x66ile\x18\x0f \x03(\x0b\x32\x34.google.protobuf.compiler.CodeGeneratorResponse.File\x1a>\n\x04\x46ile\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x17\n\x0finsertion_point\x18\x02 \x01(\t\x12\x0f\n\x07\x63ontent\x18\x0f \x01(\tB7\n\x1c\x63om.google.protobuf.compilerB\x0cPluginProtosZ\tplugin_go')
 18 | 
 19 | 
 20 | 
 21 | 
 22 | _CODEGENERATORREQUEST = _descriptor.Descriptor(
 23 |   name='CodeGeneratorRequest',
 24 |   full_name='google.protobuf.compiler.CodeGeneratorRequest',
 25 |   filename=None,
 26 |   file=DESCRIPTOR,
 27 |   containing_type=None,
 28 |   fields=[
 29 |     _descriptor.FieldDescriptor(
 30 |       name='file_to_generate', full_name='google.protobuf.compiler.CodeGeneratorRequest.file_to_generate', index=0,
 31 |       number=1, type=9, cpp_type=9, label=3,
 32 |       has_default_value=False, default_value=[],
 33 |       message_type=None, enum_type=None, containing_type=None,
 34 |       is_extension=False, extension_scope=None,
 35 |       options=None),
 36 |     _descriptor.FieldDescriptor(
 37 |       name='parameter', full_name='google.protobuf.compiler.CodeGeneratorRequest.parameter', index=1,
 38 |       number=2, type=9, cpp_type=9, label=1,
 39 |       has_default_value=False, default_value=unicode("", "utf-8"),
 40 |       message_type=None, enum_type=None, containing_type=None,
 41 |       is_extension=False, extension_scope=None,
 42 |       options=None),
 43 |     _descriptor.FieldDescriptor(
 44 |       name='proto_file', full_name='google.protobuf.compiler.CodeGeneratorRequest.proto_file', index=2,
 45 |       number=15, type=11, cpp_type=10, label=3,
 46 |       has_default_value=False, default_value=[],
 47 |       message_type=None, enum_type=None, containing_type=None,
 48 |       is_extension=False, extension_scope=None,
 49 |       options=None),
 50 |   ],
 51 |   extensions=[
 52 |   ],
 53 |   nested_types=[],
 54 |   enum_types=[
 55 |   ],
 56 |   options=None,
 57 |   is_extendable=False,
 58 |   extension_ranges=[],
 59 |   serialized_start=60,
 60 |   serialized_end=185,
 61 | )
 62 | 
 63 | 
 64 | _CODEGENERATORRESPONSE_FILE = _descriptor.Descriptor(
 65 |   name='File',
 66 |   full_name='google.protobuf.compiler.CodeGeneratorResponse.File',
 67 |   filename=None,
 68 |   file=DESCRIPTOR,
 69 |   containing_type=None,
 70 |   fields=[
 71 |     _descriptor.FieldDescriptor(
 72 |       name='name', full_name='google.protobuf.compiler.CodeGeneratorResponse.File.name', index=0,
 73 |       number=1, type=9, cpp_type=9, label=1,
 74 |       has_default_value=False, default_value=unicode("", "utf-8"),
 75 |       message_type=None, enum_type=None, containing_type=None,
 76 |       is_extension=False, extension_scope=None,
 77 |       options=None),
 78 |     _descriptor.FieldDescriptor(
 79 |       name='insertion_point', full_name='google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point', index=1,
 80 |       number=2, type=9, cpp_type=9, label=1,
 81 |       has_default_value=False, default_value=unicode("", "utf-8"),
 82 |       message_type=None, enum_type=None, containing_type=None,
 83 |       is_extension=False, extension_scope=None,
 84 |       options=None),
 85 |     _descriptor.FieldDescriptor(
 86 |       name='content', full_name='google.protobuf.compiler.CodeGeneratorResponse.File.content', index=2,
 87 |       number=15, type=9, cpp_type=9, label=1,
 88 |       has_default_value=False, default_value=unicode("", "utf-8"),
 89 |       message_type=None, enum_type=None, containing_type=None,
 90 |       is_extension=False, extension_scope=None,
 91 |       options=None),
 92 |   ],
 93 |   extensions=[
 94 |   ],
 95 |   nested_types=[],
 96 |   enum_types=[
 97 |   ],
 98 |   options=None,
 99 |   is_extendable=False,
100 |   extension_ranges=[],
101 |   serialized_start=296,
102 |   serialized_end=358,
103 | )
104 | 
105 | _CODEGENERATORRESPONSE = _descriptor.Descriptor(
106 |   name='CodeGeneratorResponse',
107 |   full_name='google.protobuf.compiler.CodeGeneratorResponse',
108 |   filename=None,
109 |   file=DESCRIPTOR,
110 |   containing_type=None,
111 |   fields=[
112 |     _descriptor.FieldDescriptor(
113 |       name='error', full_name='google.protobuf.compiler.CodeGeneratorResponse.error', index=0,
114 |       number=1, type=9, cpp_type=9, label=1,
115 |       has_default_value=False, default_value=unicode("", "utf-8"),
116 |       message_type=None, enum_type=None, containing_type=None,
117 |       is_extension=False, extension_scope=None,
118 |       options=None),
119 |     _descriptor.FieldDescriptor(
120 |       name='file', full_name='google.protobuf.compiler.CodeGeneratorResponse.file', index=1,
121 |       number=15, type=11, cpp_type=10, label=3,
122 |       has_default_value=False, default_value=[],
123 |       message_type=None, enum_type=None, containing_type=None,
124 |       is_extension=False, extension_scope=None,
125 |       options=None),
126 |   ],
127 |   extensions=[
128 |   ],
129 |   nested_types=[_CODEGENERATORRESPONSE_FILE, ],
130 |   enum_types=[
131 |   ],
132 |   options=None,
133 |   is_extendable=False,
134 |   extension_ranges=[],
135 |   serialized_start=188,
136 |   serialized_end=358,
137 | )
138 | 
139 | _CODEGENERATORREQUEST.fields_by_name['proto_file'].message_type = descriptor_pb2._FILEDESCRIPTORPROTO
140 | _CODEGENERATORRESPONSE_FILE.containing_type = _CODEGENERATORRESPONSE;
141 | _CODEGENERATORRESPONSE.fields_by_name['file'].message_type = _CODEGENERATORRESPONSE_FILE
142 | DESCRIPTOR.message_types_by_name['CodeGeneratorRequest'] = _CODEGENERATORREQUEST
143 | DESCRIPTOR.message_types_by_name['CodeGeneratorResponse'] = _CODEGENERATORRESPONSE
144 | 
145 | class CodeGeneratorRequest(_message.Message):
146 |   __metaclass__ = _reflection.GeneratedProtocolMessageType
147 |   DESCRIPTOR = _CODEGENERATORREQUEST
148 | 
149 |   # @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
150 | 
151 | class CodeGeneratorResponse(_message.Message):
152 |   __metaclass__ = _reflection.GeneratedProtocolMessageType
153 | 
154 |   class File(_message.Message):
155 |     __metaclass__ = _reflection.GeneratedProtocolMessageType
156 |     DESCRIPTOR = _CODEGENERATORRESPONSE_FILE
157 | 
158 |     # @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
159 |   DESCRIPTOR = _CODEGENERATORRESPONSE
160 | 
161 |   # @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
162 | 
163 | 
164 | DESCRIPTOR.has_options = True
165 | DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), '\n\034com.google.protobuf.compilerB\014PluginProtosZ\tplugin_go')
166 | # @@protoc_insertion_point(module_scope)
167 | 


--------------------------------------------------------------------------------
/proto_gen/plugin.proto:
--------------------------------------------------------------------------------
  1 | // Protocol Buffers - Google's data interchange format
  2 | // Copyright 2008 Google Inc.  All rights reserved.
  3 | // https://developers.google.com/protocol-buffers/
  4 | //
  5 | // Redistribution and use in source and binary forms, with or without
  6 | // modification, are permitted provided that the following conditions are
  7 | // met:
  8 | //
  9 | //     * Redistributions of source code must retain the above copyright
 10 | // notice, this list of conditions and the following disclaimer.
 11 | //     * Redistributions in binary form must reproduce the above
 12 | // copyright notice, this list of conditions and the following disclaimer
 13 | // in the documentation and/or other materials provided with the
 14 | // distribution.
 15 | //     * Neither the name of Google Inc. nor the names of its
 16 | // contributors may be used to endorse or promote products derived from
 17 | // this software without specific prior written permission.
 18 | //
 19 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 20 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 21 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 22 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 23 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 24 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 25 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 26 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 27 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 28 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 29 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30 | 
 31 | // Author: kenton@google.com (Kenton Varda)
 32 | //
 33 | // WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
 34 | //   change.
 35 | //
 36 | // protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
 37 | // just a program that reads a CodeGeneratorRequest from stdin and writes a
 38 | // CodeGeneratorResponse to stdout.
 39 | //
 40 | // Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
 41 | // of dealing with the raw protocol defined here.
 42 | //
 43 | // A plugin executable needs only to be placed somewhere in the path.  The
 44 | // plugin should be named "protoc-gen-$NAME", and will then be used when the
 45 | // flag "--${NAME}_out" is passed to protoc.
 46 | 
 47 | syntax = "proto2";
 48 | package google.protobuf.compiler;
 49 | option java_package = "com.google.protobuf.compiler";
 50 | option java_outer_classname = "PluginProtos";
 51 | 
 52 | option go_package = "plugin_go";
 53 | 
 54 | import "descriptor.proto";
 55 | 
 56 | // An encoded CodeGeneratorRequest is written to the plugin's stdin.
 57 | message CodeGeneratorRequest {
 58 |   // The .proto files that were explicitly listed on the command-line.  The
 59 |   // code generator should generate code only for these files.  Each file's
 60 |   // descriptor will be included in proto_file, below.
 61 |   repeated string file_to_generate = 1;
 62 | 
 63 |   // The generator parameter passed on the command-line.
 64 |   optional string parameter = 2;
 65 | 
 66 |   // FileDescriptorProtos for all files in files_to_generate and everything
 67 |   // they import.  The files will appear in topological order, so each file
 68 |   // appears before any file that imports it.
 69 |   //
 70 |   // protoc guarantees that all proto_files will be written after
 71 |   // the fields above, even though this is not technically guaranteed by the
 72 |   // protobuf wire format.  This theoretically could allow a plugin to stream
 73 |   // in the FileDescriptorProtos and handle them one by one rather than read
 74 |   // the entire set into memory at once.  However, as of this writing, this
 75 |   // is not similarly optimized on protoc's end -- it will store all fields in
 76 |   // memory at once before sending them to the plugin.
 77 |   repeated FileDescriptorProto proto_file = 15;
 78 | }
 79 | 
 80 | // The plugin writes an encoded CodeGeneratorResponse to stdout.
 81 | message CodeGeneratorResponse {
 82 |   // Error message.  If non-empty, code generation failed.  The plugin process
 83 |   // should exit with status code zero even if it reports an error in this way.
 84 |   //
 85 |   // This should be used to indicate errors in .proto files which prevent the
 86 |   // code generator from generating correct code.  Errors which indicate a
 87 |   // problem in protoc itself -- such as the input CodeGeneratorRequest being
 88 |   // unparseable -- should be reported by writing a message to stderr and
 89 |   // exiting with a non-zero status code.
 90 |   optional string error = 1;
 91 | 
 92 |   // Represents a single generated file.
 93 |   message File {
 94 |     // The file name, relative to the output directory.  The name must not
 95 |     // contain "." or ".." components and must be relative, not be absolute (so,
 96 |     // the file cannot lie outside the output directory).  "/" must be used as
 97 |     // the path separator, not "\".
 98 |     //
 99 |     // If the name is omitted, the content will be appended to the previous
100 |     // file.  This allows the generator to break large files into small chunks,
101 |     // and allows the generated text to be streamed back to protoc so that large
102 |     // files need not reside completely in memory at one time.  Note that as of
103 |     // this writing protoc does not optimize for this -- it will read the entire
104 |     // CodeGeneratorResponse before writing files to disk.
105 |     optional string name = 1;
106 | 
107 |     // If non-empty, indicates that the named file should already exist, and the
108 |     // content here is to be inserted into that file at a defined insertion
109 |     // point.  This feature allows a code generator to extend the output
110 |     // produced by another code generator.  The original generator may provide
111 |     // insertion points by placing special annotations in the file that look
112 |     // like:
113 |     //   @@protoc_insertion_point(NAME)
114 |     // The annotation can have arbitrary text before and after it on the line,
115 |     // which allows it to be placed in a comment.  NAME should be replaced with
116 |     // an identifier naming the point -- this is what other generators will use
117 |     // as the insertion_point.  Code inserted at this point will be placed
118 |     // immediately above the line containing the insertion point (thus multiple
119 |     // insertions to the same point will come out in the order they were added).
120 |     // The double-@ is intended to make it unlikely that the generated code
121 |     // could contain things that look like insertion points by accident.
122 |     //
123 |     // For example, the C++ code generator places the following line in the
124 |     // .pb.h files that it generates:
125 |     //   // @@protoc_insertion_point(namespace_scope)
126 |     // This line appears within the scope of the file's package namespace, but
127 |     // outside of any particular class.  Another plugin can then specify the
128 |     // insertion_point "namespace_scope" to generate additional classes or
129 |     // other declarations that should be placed in this scope.
130 |     //
131 |     // Note that if the line containing the insertion point begins with
132 |     // whitespace, the same whitespace will be added to every line of the
133 |     // inserted text.  This is useful for languages like Python, where
134 |     // indentation matters.  In these languages, the insertion point comment
135 |     // should be indented the same amount as any inserted code will need to be
136 |     // in order to work correctly in that context.
137 |     //
138 |     // The code generator that generates the initial file and the one which
139 |     // inserts into it must both run as part of a single invocation of protoc.
140 |     // Code generators are executed in the order in which they appear on the
141 |     // command line.
142 |     //
143 |     // If |insertion_point| is present, |name| must also be present.
144 |     optional string insertion_point = 2;
145 | 
146 |     // The file contents.
147 |     optional string content = 15;
148 |   }
149 |   repeated File file = 15;
150 | }
151 | 


--------------------------------------------------------------------------------
/ucorf/client_impl.cpp:
--------------------------------------------------------------------------------
  1 | #include "client_impl.h"
  2 | #include "error.h"
  3 | #include "dispatcher.h"
  4 | #include "logger.h"
  5 | #include "message.h"
  6 | #include "net_transport.h"
  7 | 
  8 | namespace ucorf
  9 | {
 10 |     ClientImpl::ClientImpl()
 11 |         : opt_(new Option), dispatcher_(new RobinDispatcher),
 12 |         head_factory_(&UcorfHead::Factory), default_srv_finder_(new ServerFinder),
 13 |         tp_factory_([]{ return static_cast<ITransportClient*>(new NetTransportClient); })
 14 |     {
 15 |         default_srv_finder_->SetConnectedCb(boost::bind(&ClientImpl::OnConnected, this, _1, _2));
 16 |         default_srv_finder_->SetReceiveCb(boost::bind(&ClientImpl::OnReceiveData, this, _1, _2, _3, _4));
 17 |         default_srv_finder_->SetDisconnectedCb(boost::bind(&ClientImpl::OnDisconnected, this, _1, _2, _3));
 18 |         default_srv_finder_->SetOption(opt_);
 19 |     }
 20 | 
 21 |     ClientImpl::~ClientImpl()
 22 |     {
 23 |     }
 24 | 
 25 |     ClientImpl& ClientImpl::SetOption(boost::shared_ptr<Option> opt)
 26 |     {
 27 |         opt_ = opt;
 28 |         if (default_srv_finder_)
 29 |             default_srv_finder_->SetOption(opt_);
 30 | 
 31 |         for (auto &finder : srv_finders_)
 32 |             finder->SetOption(opt_);
 33 |         return *this;
 34 |     }
 35 | 
 36 |     ClientImpl& ClientImpl::SetDispatcher(std::unique_ptr<IDispatcher> && dispatcher)
 37 |     {
 38 |         dispatcher_.reset();
 39 |         dispatcher_.swap(dispatcher);
 40 |         return *this;
 41 |     }
 42 | 
 43 |     ClientImpl& ClientImpl::SetHeaderFactory(HeaderFactory const& head_factory)
 44 |     {
 45 |         head_factory_ = head_factory;
 46 |         return *this;
 47 |     }
 48 | 
 49 |     ClientImpl& ClientImpl::SetServerFinder(std::unique_ptr<ServerFinder> && srv_finder)
 50 |     {
 51 |         if (default_srv_finder_) default_srv_finder_.reset();
 52 | 
 53 |         srv_finder->SetConnectedCb(boost::bind(&ClientImpl::OnConnected, this, _1, _2));
 54 |         srv_finder->SetReceiveCb(boost::bind(&ClientImpl::OnReceiveData, this, _1, _2, _3, _4));
 55 |         srv_finder->SetDisconnectedCb(boost::bind(&ClientImpl::OnDisconnected, this, _1, _2, _3));
 56 |         srv_finder->SetOption(opt_);
 57 |         if (!url_.empty())
 58 |             srv_finder->Init(url_, tp_factory_);
 59 |         srv_finders_.emplace_back(std::move(srv_finder));
 60 |         return *this;
 61 |     }
 62 | 
 63 |     ClientImpl& ClientImpl::SetTransportFactory(TransportFactory const& factory)
 64 |     {
 65 |         tp_factory_ = factory;
 66 |         return *this;
 67 |     }
 68 | 
 69 |     ClientImpl& ClientImpl::SetUrl(std::string const& url)
 70 |     {
 71 |         url_ = url;
 72 |         if (default_srv_finder_)
 73 |             default_srv_finder_->Init(url_, tp_factory_);
 74 | 
 75 |         for (auto &finder : srv_finders_)
 76 |             finder->Init(url_, tp_factory_);
 77 |         return *this;
 78 |     }
 79 | 
 80 |     boost_ec ClientImpl::Call(std::string const& service_name,
 81 |             std::string const& method_name,
 82 |             IMessage *request, IMessage *response)
 83 |     {
 84 |         if (wnd_size_ > opt_->request_wnd_size)
 85 |             return MakeUcorfErrorCode(eUcorfErrorCode::ec_req_wnd_full);
 86 | 
 87 |         boost::shared_ptr<ITransportClient> tp = dispatcher_->Get(service_name, method_name, request);
 88 |         if (!tp) {
 89 |             bool ok = false;
 90 |             boost_ec last_ec;
 91 |             if (default_srv_finder_) {
 92 |                 boost_ec ec = default_srv_finder_->ReConnect();
 93 |                 if (ec) {
 94 |                     last_ec = ec;
 95 |                     ucorf_log_error("connect to %s error: %s", url_.c_str(), ec.message().c_str());
 96 |                 } else
 97 |                     ok = true;
 98 |             }
 99 | 
100 |             for (auto &finder : srv_finders_) {
101 |                 boost_ec ec = finder->ReConnect();
102 |                 if (ec) {
103 |                     last_ec = ec;
104 |                     ucorf_log_error("connect to %s error: %s", url_.c_str(), ec.message().c_str());
105 |                 } else
106 |                     ok = true;
107 |             }
108 |             if (!ok)
109 |                 return last_ec;
110 | 
111 |             tp = dispatcher_->Get(service_name, method_name, request);
112 |         }
113 | 
114 |         if (!tp || !tp->IsEstab()) {
115 |             return MakeUcorfErrorCode(eUcorfErrorCode::ec_no_estab);
116 |         }
117 | 
118 |         IHeaderPtr header = head_factory_();
119 |         std::size_t msg_id = ++msg_id_;
120 |         header->SetId(msg_id);
121 |         header->SetType(response ? eHeaderType::request : eHeaderType::oneway_request);
122 |         header->SetFollowBytes(request->ByteSize());
123 |         header->SetService(service_name);
124 |         header->SetMethod(method_name);
125 |         std::vector<char> buf;
126 |         buf.resize(header->ByteSize() + request->ByteSize());
127 |         header->Serialize(&buf[0], header->ByteSize());
128 |         request->Serialize(&buf[header->ByteSize()], request->ByteSize());
129 |         if (!response) {
130 |             co_chan<boost_ec> cc(1);
131 |             tp->Send(std::move(buf), [=](boost_ec const& ec) { cc << ec; });
132 |             boost_ec ec;
133 |             cc >> ec;
134 |             return ec;
135 |         } else {
136 |             std::unique_lock<co_mutex> channel_lock(channel_mtx_);
137 |             auto it_1 = channels_.find(tp.get());
138 |             if (channels_.end() == it_1)
139 |                 return MakeUcorfErrorCode(eUcorfErrorCode::ec_no_estab);
140 |             auto chan_grp = it_1->second;
141 |             channel_lock.unlock();
142 | 
143 |             auto chan = RspChan(1);
144 |             int map_idx = msg_id & (e_chan_group_count - 1);
145 | 
146 |             RspChanMap &chan_map = chan_grp->maps[map_idx];
147 |             co_mutex &mtx = chan_grp->mtxs[map_idx];
148 | 
149 |             std::unique_lock<co_mutex> map_lock(mtx);
150 |             if (chan_grp->closed[map_idx])
151 |                 return MakeUcorfErrorCode(eUcorfErrorCode::ec_no_estab);
152 |             chan_map[msg_id] = chan;
153 |             map_lock.unlock();
154 | 
155 |             tp->Send(&buf[0], buf.size(), [=](boost_ec const& ec){
156 |                         if (ec) {
157 |                             chan.TryPush(ec);
158 |                         }
159 |                     });
160 |             ++wnd_size_;
161 | 
162 |             ResponseData rsp;
163 |             if (opt_->rcv_timeout_ms) {
164 |                 if (!chan.TimedPop(rsp, std::chrono::milliseconds(opt_->rcv_timeout_ms)))
165 |                     return MakeUcorfErrorCode(eUcorfErrorCode::ec_rcv_timeout);
166 |             } else
167 |                 chan >> rsp;
168 | 
169 |             --wnd_size_;
170 | 
171 |             {
172 |                 std::unique_lock<co_mutex> map_lock(mtx);
173 |                 chan_map.erase(msg_id);
174 |             }
175 | 
176 |             if (rsp.ec)
177 |                 return rsp.ec;
178 | 
179 |             if (rsp.data.empty() || !response->Parse(&rsp.data[0], rsp.data.size()))
180 |                 return MakeUcorfErrorCode(eUcorfErrorCode::ec_parse_error);
181 |         }
182 | 
183 |         return boost_ec();
184 |     }
185 | 
186 |     void ClientImpl::OnConnected(boost::shared_ptr<ITransportClient> tp, SessId sess_id)
187 |     {
188 |         dispatcher_->Add(tp);
189 | 
190 |         std::unique_lock<co_mutex> channel_lock(channel_mtx_);
191 |         channels_[tp.get()].reset(new RspChanGroup);
192 |     }
193 |     void ClientImpl::OnDisconnected(boost::shared_ptr<ITransportClient> tp, SessId sess_id, boost_ec const& ec)
194 |     {
195 |         dispatcher_->Del(tp);
196 | 
197 |         std::unique_lock<co_mutex> channel_lock(channel_mtx_);
198 |         auto it_1 = channels_.find(tp.get());
199 |         if (channels_.end() == it_1) return ;
200 |         auto chan_grp = it_1->second;
201 |         channels_.erase(it_1);
202 |         channel_lock.unlock();
203 | 
204 |         for (int i = 0; i < e_chan_group_count; ++i)
205 |         {
206 |             std::unique_lock<co_mutex> map_lock(chan_grp->mtxs[i]);
207 |             chan_grp->closed[i] = true;
208 |             auto &map = chan_grp->maps[i];
209 |             for (auto &kv : map)
210 |                 kv.second.TryPush(ec);
211 |         }
212 |     }
213 | 
214 | //    static std::string to_14_hex(const char* data, size_t len)
215 | //    {
216 | //        static const char hex[] = "0123456789abcdef";
217 | //        len = std::min<size_t>(len, 28);
218 | //        std::string str;
219 | //        for (size_t i = 0; i < len; ++i) {
220 | //            str += hex[(unsigned char)data[i] >> 4];
221 | //            str += hex[(unsigned char)data[i] & 0xf];
222 | //            str += ' ';
223 | //        }
224 | //        return str;
225 | //    }
226 | 
227 |     size_t ClientImpl::OnReceiveData(boost::shared_ptr<ITransportClient> tp, SessId sess_id, const char* data, size_t bytes)
228 |     {
229 |         size_t consume = 0;
230 |         const char* buf = data;
231 |         size_t len = bytes;
232 | 
233 |         int yield_c = 0;
234 |         while (consume < bytes)
235 |         {
236 |             IHeaderPtr header = head_factory_();
237 |             size_t head_len = header->Parse(buf, len);
238 |             if (!head_len) {
239 | //                ucorf_log_verb("header parse error, len = %u, bin: %s", (unsigned)len, to_14_hex(buf, len).c_str());
240 |                 break;
241 |             }
242 | 
243 |             size_t follow_bytes = header->GetFollowBytes();
244 |             if (head_len + follow_bytes > len) {
245 | //                ucorf_log_verb("follow bytes too less, head_len = %u, follow_bytes = %u, len = %u", (unsigned)head_len, (unsigned)follow_bytes, (unsigned)len);
246 |                 break;
247 |             }
248 | 
249 |             OnResponse(tp, header, buf + head_len, follow_bytes);
250 | 
251 |             consume += head_len + follow_bytes;
252 |             buf = data + consume;
253 |             len = bytes - consume;
254 | 
255 |             if ((++yield_c & 0xff) == 0)
256 |                 co_yield;
257 |         }
258 | 
259 |         if (yield_c <= 0xff)
260 |             co_yield;
261 | 
262 | //        ucorf_log_debug("consume %u bytes from %u bytes", (unsigned)consume, (unsigned)bytes);
263 |         return consume;
264 |     }
265 | 
266 |     void ClientImpl::OnResponse(boost::shared_ptr<ITransportClient> tp, IHeaderPtr header, const char* data, size_t bytes)
267 |     {
268 | //        ucorf_log_debug("receive response. srv=%s, method=%s, msgid=%llu",
269 | //                header->GetService().c_str(), header->GetMethod().c_str(), (unsigned long long)header->GetId());
270 | 
271 |         std::size_t msg_id = header->GetId();
272 | 
273 |         std::unique_lock<co_mutex> channel_lock(channel_mtx_);
274 |         auto it_1 = channels_.find(tp.get());
275 |         if (channels_.end() == it_1) {
276 |             ucorf_log_warn("discard response because connection was disconnected. srv=%s, method=%s, msgid=%llu",
277 |                     header->GetService().c_str(), header->GetMethod().c_str(), (unsigned long long)header->GetId());
278 |             return ;
279 |         }
280 |         auto chan_grp = it_1->second;
281 |         channel_lock.unlock();
282 | 
283 |         int map_idx = msg_id & (e_chan_group_count - 1);
284 | 
285 |         RspChanMap &chan_map = chan_grp->maps[map_idx];
286 |         co_mutex &mtx = chan_grp->mtxs[map_idx];
287 | 
288 |         std::unique_lock<co_mutex> map_lock(mtx);
289 |         auto it_2 = chan_map.find(msg_id);
290 |         if (chan_map.end() == it_2) {
291 |             ucorf_log_warn("discard response because stub was timeout. srv=%s, method=%s, msgid=%llu",
292 |                     header->GetService().c_str(), header->GetMethod().c_str(), (unsigned long long)header->GetId());
293 |             return ;
294 |         }
295 |         auto chan = it_2->second;
296 |         map_lock.unlock();
297 | 
298 |         ResponseData rsp;
299 |         rsp.header = header;
300 |         rsp.data.resize(bytes);
301 |         memcpy(&rsp.data[0], data, bytes);
302 |         chan.TryPush(rsp);
303 |     }
304 | 
305 | } //namespace ucorf
306 | 
307 | 


--------------------------------------------------------------------------------
/ucorf/zookeeper.cpp:
--------------------------------------------------------------------------------
  1 | #include "zookeeper.h"
  2 | #include "logger.h"
  3 | #include <boost/algorithm/string.hpp>
  4 | #include <boost/regex.hpp>
  5 | 
  6 | namespace ucorf
  7 | {
  8 |     void ZookeeperClient::__watcher_fn(zhandle_t *zh, int type, 
  9 |         int state, const char *path, void *watcherCtx)
 10 |     {
 11 |         ZookeeperClient *self = (ZookeeperClient*)watcherCtx;
 12 |         std::string spath = path;
 13 |         OnWatchF fn = [=]{
 14 |             self->OnWatch(zh, type, state, spath);
 15 |         };
 16 |         self->event_chan_ << fn;
 17 |     }
 18 | 
 19 |     ZookeeperClient::ZookeeperClient()
 20 |         : event_chan_(128)
 21 |     {}
 22 | 
 23 |     void ZookeeperClient::Init(std::string zk_host)
 24 |     {
 25 |         host_ = zk_host;
 26 |         go [this] {
 27 |             for (;;) {
 28 |                 OnWatchF fn;
 29 |                 event_chan_ >> fn;
 30 |                 fn();
 31 |             }
 32 |         };
 33 |         go [this]{ this->Connect(); };
 34 |     }
 35 | 
 36 |     bool ZookeeperClient::WaitForConnected(unsigned timeout_ms)
 37 |     {
 38 |         auto begin = std::chrono::system_clock::now();
 39 |         while (!timeout_ms || std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - begin).count() < timeout_ms) {
 40 |             if (zk_) return true;
 41 |             co_sleep(1);
 42 |         }
 43 | 
 44 |         return false;
 45 |     }
 46 | 
 47 |     bool ZookeeperClient::Watch(std::string path, WatchCb const& cb, void* key)
 48 |     {
 49 |         std::unique_lock<co_mutex> lock(mutex_);
 50 |         WatcherMap &m = zk_watchers_[path];
 51 |         bool ok = m.insert(WatcherMap::value_type(key, cb)).second;
 52 |         if (!ok)
 53 |             return false;
 54 | 
 55 |         if (!zk_) return true;
 56 | 
 57 |         if (__Watch(path, cb)) {
 58 |             m.erase(key);
 59 |             return false;
 60 |         }
 61 | 
 62 |         return true;
 63 |     }
 64 | 
 65 |     bool ZookeeperClient::__Watch(std::string path, WatchCb const& cb)
 66 |     {
 67 |         if (!zk_) {
 68 |             ucorf_log_error("watch zookeeper node(%s) error "
 69 |                     " because zhandle_t is null.", path.c_str());
 70 |             return false;
 71 |         }
 72 | 
 73 |         // get children.
 74 |         String_vector children;
 75 | retry:
 76 |         int ret = zoo_get_children(zk_, path.c_str(), 1, &children);
 77 |         switch (ret) {
 78 |             case ZOK:
 79 |             {
 80 |                 Children c;
 81 |                 for (int32_t i = 0; i < children.count; ++i)
 82 |                     c.push_back(children.data[i]);
 83 |                 deallocate_String_vector(&children);
 84 |                 if (cb)
 85 |                     cb(c);
 86 |                 else {
 87 |                     auto &m = zk_watchers_[path];
 88 |                     for (auto &kv : m)
 89 |                         kv.second(c);
 90 |                 }
 91 |                 return true;
 92 |             }
 93 | 
 94 |             case ZNONODE:
 95 |             {
 96 |                 // Create path recursive.
 97 |                 if (!CreateNode(path, eCreateNodeFlags::normal, true, false)) {
 98 |                     return false;
 99 |                 }
100 | 
101 |                 goto retry;
102 |             }
103 | 
104 |             default:
105 |             {
106 |                 ucorf_log_error("zoo_get_children from zookeeper node(%s) error: %s",
107 |                         path.c_str(), zerror(errno));
108 |                 return false;
109 |             }
110 |         }
111 |     }
112 | 
113 |     void ZookeeperClient::Unwatch(std::string path, void* key)
114 |     {
115 |         std::unique_lock<co_mutex> lock(mutex_);
116 |         auto it = zk_watchers_.find(path);
117 |         if (it != zk_watchers_.end())
118 |             it->second.erase(key);
119 |     }
120 | 
121 |     bool ZookeeperClient::CreateNode(std::string path, eCreateNodeFlags flags,
122 |             bool recursive, bool is_lock)
123 |     {
124 |         std::unique_lock<co_mutex> lock(mutex_, std::defer_lock);
125 |         if (is_lock) lock.lock();
126 | 
127 |         if (!zk_) {
128 |             ucorf_log_error("create zookeeper node(%s) error "
129 |                     " because zhandle_t is null.", path.c_str());
130 |             return false;
131 |         }
132 | 
133 |         char buf[1] = {};
134 |         if (recursive) {
135 |             std::string::size_type pos = 0;
136 |             do {
137 |                 pos = path.find("/", pos + 1);
138 |                 if (pos == std::string::npos) break;
139 |                 std::string parent = path.substr(0, pos);
140 |                 int ret = zoo_create(zk_, parent.c_str(), nullptr, -1, &ZOO_OPEN_ACL_UNSAFE, 0, buf, 0);
141 |                 if (ret != ZOK && ret != ZNODEEXISTS) {
142 |                     ucorf_log_error("create zookeeper node(%s) returns %d error: %s",
143 |                             parent.c_str(), ret, zerror(errno));
144 |                     return false;
145 |                 } else {
146 |                     ucorf_log_debug("create node(%s) to zookeeper(%s) success.", parent.c_str(), host_.c_str());
147 |                 }
148 |             } while (pos != std::string::npos);
149 |         }
150 | 
151 |         int cflag = 0;
152 |         if (flags == eCreateNodeFlags::ephemeral)
153 |             cflag = ZOO_EPHEMERAL;
154 |         else if (flags == eCreateNodeFlags::sequence)
155 |             cflag = ZOO_SEQUENCE;
156 | 
157 |         int ret = zoo_create(zk_, path.c_str(), nullptr, -1, &ZOO_OPEN_ACL_UNSAFE, cflag, buf, 0);
158 |         if (ret != ZOK && ret != ZNODEEXISTS) {
159 |             ucorf_log_error("create zookeeper node(%s) returns %d error: %s",
160 |                     path.c_str(), ret, zerror(errno));
161 |             return false;
162 |         } else {
163 |             ucorf_log_debug("create node(%s) to zookeeper(%s) success.", path.c_str(), host_.c_str());
164 |         }
165 | 
166 |         if (flags == eCreateNodeFlags::ephemeral)
167 |             ephemeral_nodes_.insert(path);
168 | 
169 |         return true;
170 |     }
171 | 
172 |     bool ZookeeperClient::DelayCreateEphemeralNode(std::string path, bool is_lock)
173 |     {
174 |         std::unique_lock<co_mutex> lock(mutex_, std::defer_lock);
175 |         if (is_lock) lock.lock();
176 | 
177 |         ephemeral_nodes_.insert(path);
178 | 
179 |         if (!zk_) return true;
180 | 
181 |         char buf[1] = {};
182 |         std::string::size_type pos = 0;
183 |         do {
184 |             pos = path.find("/", pos + 1);
185 |             if (pos == std::string::npos) break;
186 |             std::string parent = path.substr(0, pos);
187 |             int ret = zoo_create(zk_, parent.c_str(), nullptr, -1, &ZOO_OPEN_ACL_UNSAFE, 0, buf, 0);
188 |             if (ret != ZOK && ret != ZNODEEXISTS) {
189 |                 ucorf_log_error("create zookeeper node(%s) returns %d error: %s",
190 |                         parent.c_str(), ret, zerror(errno));
191 |                 return false;
192 |             } else {
193 |                 ucorf_log_debug("create node(%s) to zookeeper(%s) success.", parent.c_str(), host_.c_str());
194 |             }
195 |         } while (pos != std::string::npos);
196 | 
197 |         int ret = zoo_create(zk_, path.c_str(), nullptr, -1, &ZOO_OPEN_ACL_UNSAFE, ZOO_EPHEMERAL, buf, 0);
198 |         if (ret == ZOK) {
199 |             ucorf_log_debug("create node(%s) to zookeeper(%s) success.", path.c_str(), host_.c_str());
200 |         } else if (ret == ZNODEEXISTS) {
201 |             // retry ...
202 |             ucorf_log_debug("create node(%s) to zookeeper(%s) error because exists, will retry ...", path.c_str(), host_.c_str());
203 |             go [=] {
204 |                 co_sleep(3000);
205 |                 std::unique_lock<co_mutex> lock(mutex_);
206 |                 if (this->ephemeral_nodes_.count(path))
207 |                     this->DelayCreateEphemeralNode(path, false);
208 |             };
209 |         } else {
210 |             ucorf_log_error("create zookeeper node(%s) returns %d error: %s",
211 |                     path.c_str(), ret, zerror(errno));
212 |             return false;
213 |         }
214 | 
215 |         return true;
216 |     }
217 | 
218 |     bool ZookeeperClient::DeleteNode(std::string path)
219 |     {
220 |         std::unique_lock<co_mutex> lock(mutex_);
221 |         if (!zk_) {
222 |             ucorf_log_error("delete zookeeper node(%s) error "
223 |                     " because zhandle_t is null.", path.c_str());
224 |             return false;
225 |         }
226 | 
227 |         int ret = zoo_delete(zk_, path.c_str(), -1);
228 |         if (ret != ZOK || ret != ZNONODE) {
229 |             ucorf_log_error("delete zookeeper node(%s) returns %d error: %s",
230 |                     path.c_str(), ret, zerror(errno));
231 |             return false;
232 |         }
233 | 
234 |         ephemeral_nodes_.erase(path);
235 |         return true;
236 |     }
237 | 
238 |     void ZookeeperClient::Connect()
239 |     {
240 |         zhandle_t *zk = zookeeper_init(host_.c_str(), &ZookeeperClient::__watcher_fn,
241 |                 ZookeeperClientMgr::getInstance().GetTimeout(),
242 |                 nullptr, this, 0);
243 |         if (!zk) {
244 |             ucorf_log_error("connect to zookeeper (%s) error: %s. delay 3s retry...",
245 |                     host_.c_str(), zerror(errno));
246 |             go [this]{ 
247 |                 co_sleep(3000);
248 |                 this->Connect(); 
249 |             };
250 |             return ;
251 |         }
252 |     }
253 | 
254 |     void ZookeeperClient::OnWatch(zhandle_t *zh, int type, int state, std::string path)
255 |     {
256 |         std::unique_lock<co_mutex> lock(mutex_);
257 |         ucorf_log_notice("zookeeper trigger type=%d state=%d path=%s ",
258 |                 type, state, path.c_str());
259 | 
260 |         if (type == ZOO_SESSION_EVENT) {
261 |             if (state == ZOO_CONNECTED_STATE) {
262 |                 ucorf_log_notice("connect to zookeeper(%s) success!", host_.c_str());
263 |                 zk_ = zh;
264 |                 for (auto &kv : zk_watchers_)
265 |                     __Watch(kv.first);
266 |                 for (auto &node : ephemeral_nodes_)
267 |                     if (!DelayCreateEphemeralNode(node, false)) {
268 |                         ucorf_log_error("create ephemeral node(%s) to zookeeper(%s) error.",
269 |                                 node.c_str(), host_.c_str());
270 |                     }
271 |             } else {
272 |                 if (zk_) {
273 |                     zookeeper_close(zk_);
274 |                     zk_ = nullptr;
275 |                 }
276 | 
277 |                 go [this]{ this->Connect(); };
278 |                 return ;
279 |             }
280 |         } else if (type == ZOO_CHILD_EVENT) {
281 |             __Watch(path);
282 |         } else {
283 |             // ignore other event.
284 |         }
285 |     }
286 | 
287 |     ZookeeperClientMgr& ZookeeperClientMgr::getInstance()
288 |     {
289 |         static ZookeeperClientMgr obj;
290 |         return obj;
291 |     }
292 | 
293 |     void ZookeeperClientMgr::SetTimeout(int timeo)
294 |     {
295 |         zk_timeout_ = timeo;
296 |     }
297 | 
298 |     int ZookeeperClientMgr::GetTimeout()
299 |     {
300 |         return zk_timeout_;
301 |     }
302 | 
303 |     boost::shared_ptr<ZookeeperClient> ZookeeperClientMgr::GetZookeeperClient(std::string zk_host)
304 |     {
305 |         std::unique_lock<co_mutex> lock(mutex_);
306 |         auto it = zk_clients_.find(zk_host);
307 |         if (it == zk_clients_.end()) {
308 |             auto c = boost::make_shared<ZookeeperClient>();
309 |             c->Init(zk_host);
310 |             zk_clients_[zk_host] = c;
311 |             return c;
312 |         }
313 | 
314 |         return it->second;
315 |     }
316 | 
317 |     std::pair<std::string, std::string> ZookeeperClientMgr::ParseZookeeperUrl(std::string url)
318 |     {
319 |         std::pair<std::string, std::string> result;
320 |         const char* zk_prefix = "zk://";
321 |         if (!boost::istarts_with(url, zk_prefix)) {
322 |             ucorf_log_error("zookeeper url must be starts with \"zk://\"");
323 |             return result;
324 |         }
325 | 
326 |         size_t addr_begin = strlen(zk_prefix);
327 |         size_t path_begin = url.find('/', addr_begin);
328 |         if (std::string::npos == path_begin) {
329 |             ucorf_log_error("zookeeper url must be have path, starts with '/'");
330 |             return result;
331 |         }
332 | 
333 |         result.first = url.substr(addr_begin, path_begin - addr_begin);
334 |         result.second = url.substr(path_begin, -1);
335 |         return result;
336 |     }
337 |     std::string ZookeeperClientMgr::Url2ZookeeperNode(std::string url)
338 |     {
339 |         static ::boost::regex re("((.*)://)?([^/]+)");
340 |         boost::smatch result;
341 |         bool ok = boost::regex_match(url, result, re);
342 |         if (!ok) {
343 |             return "";
344 |         }
345 | 
346 |         std::string proto = result[2].str();
347 |         if (proto.empty()) proto = "TCP";
348 |         std::string addr = result[3];
349 |         return addr + ":" + proto;
350 |     }
351 |     std::string ZookeeperClientMgr::ZookeeperNode2Url(std::string node)
352 |     {
353 |         size_t pos = node.find_last_of(':');
354 |         if (pos == std::string::npos) return "";
355 | 
356 |         std::string proto = node.substr(pos + 1, -1);
357 |         std::string addr = node.substr(0, pos);
358 |         return proto + "://" + addr;
359 |     }
360 | 
361 | } //namespace ucorf
362 | 


--------------------------------------------------------------------------------
/ucorf/hprose/hprose_protocol.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <type_traits>
  4 | #include <string>
  5 | #include <stdlib.h>
  6 | #include <limits>
  7 | #include <time.h>
  8 | #include <chrono>
  9 | #include <boost/uuid/uuid.hpp>
 10 | #include <boost/uuid/string_generator.hpp>
 11 | 
 12 | namespace ucorf {
 13 | namespace hprose {
 14 | 
 15 | /* Serialize Tags */
 16 | const char TagInteger     = 'i';
 17 | const char TagLong        = 'l';
 18 | const char TagDouble      = 'd';
 19 | const char TagNull        = 'n';
 20 | const char TagEmpty       = 'e';
 21 | const char TagTrue        = 't';
 22 | const char TagFalse       = 'f';
 23 | const char TagNaN         = 'N';
 24 | const char TagInfinity    = 'I';
 25 | const char TagDate        = 'D';
 26 | const char TagTime        = 'T';
 27 | const char TagUTC         = 'Z';
 28 | const char TagBytes       = 'b';
 29 | const char TagUTF8Char    = 'u';
 30 | const char TagString      = 's';
 31 | const char TagGuid        = 'g';  
 32 | const char TagList        = 'a';
 33 | const char TagMap         = 'm';
 34 | const char TagClass       = 'c';
 35 | const char TagObject      = 'o';
 36 | const char TagRef         = 'r';
 37 | /* Serialize Marks */
 38 | const char TagPos         = '+';
 39 | const char TagNeg         = '-';
 40 | const char TagSemicolon   = ';';
 41 | const char TagOpenbrace   = '{';
 42 | const char TagClosebrace  = '}';
 43 | const char TagQuote       = '"';
 44 | const char TagPoint       = '.';
 45 | /* Protocol Tags */
 46 | const char TagFunctions   = 'F';
 47 | const char TagCall        = 'C';
 48 | const char TagResult      = 'R';
 49 | const char TagArgument    = 'A';
 50 | const char TagError       = 'E';
 51 | const char TagEnd         = 'z';
 52 | 
 53 | template <typename Container>
 54 | struct has_mapped_type
 55 | {
 56 |     template <typename T>
 57 |     static void test(T *, typename T::mapped_type* = nullptr) noexcept(true);
 58 | 
 59 |     template <typename T>
 60 |     static void test(void *, ...) noexcept(false);
 61 | 
 62 |     static const bool value = noexcept(test<Container>((Container*)nullptr));
 63 | };
 64 | 
 65 | struct Buffer
 66 | {
 67 |     std::string s_;
 68 |     size_t read_pos_ = 0;
 69 | 
 70 |     struct rb_sentry
 71 |     {
 72 |         Buffer *buf_ = nullptr;
 73 |         size_t pos_ = 0;
 74 |         bool commit_ = false;
 75 | 
 76 |         explicit rb_sentry(Buffer * b) : buf_(b) {
 77 |             pos_ = buf_->read_pos_;
 78 |         }
 79 |         size_t begin() { return pos_; }
 80 |         void commit() { commit_ = true; }
 81 |         ~rb_sentry() {
 82 |             if (!commit_)
 83 |                 buf_->read_pos_ = pos_;
 84 |         }
 85 |     };
 86 | 
 87 |     Buffer() {}
 88 |     explicit Buffer(std::string const& s) : s_(s) {}
 89 |     Buffer(const void* b, size_t len) : s_((const char*)b, len) {}
 90 | 
 91 |     std::string const& str()
 92 |     {
 93 |         return s_;
 94 |     }
 95 | 
 96 |     int get()
 97 |     {
 98 |         if (read_pos_ >= s_.size()) return -1;
 99 |         return (int)(unsigned char)s_[read_pos_++];
100 |     }
101 | 
102 |     void rollback(size_t n = 1)
103 |     {
104 |         read_pos_ -= n;
105 |     }
106 | 
107 |     // 结果不包含字符c
108 |     std::string ReadUntil(char c)
109 |     {
110 |         rb_sentry rb(this);
111 |         for (;;) {
112 |             int v = get();
113 |             if (v == -1)
114 |                 return "";
115 | 
116 |             if (v == c) {
117 |                 rb.commit();
118 |                 return s_.substr(rb.begin(), read_pos_ - rb.begin());
119 |             }
120 | 
121 |             ++v;
122 |         }
123 |     }
124 | 
125 |     // 取N个bytes
126 |     std::string ReadN(size_t n)
127 |     {
128 |         if (read_pos_ + n < s_.size()) {
129 |             read_pos_ += n;
130 |             return s_.substr(read_pos_ - n, n);
131 |         }
132 | 
133 |         return "";
134 |     }
135 | 
136 |     // integer and long
137 |     template <typename Integer>
138 |     typename std::enable_if<std::is_integral<Integer>::value && !std::is_same<Integer, bool>::value,
139 |              bool>::type
140 |     Read(Integer & i)
141 |     {
142 |         rb_sentry rb(this);
143 |         bool b = __Read(i);
144 |         if (b) rb.commit();
145 |         return b;
146 |     }
147 | 
148 |     template <typename Integer>
149 |     typename std::enable_if<std::is_integral<Integer>::value && !std::is_same<Integer, bool>::value,
150 |              bool>::type
151 |     __Read(Integer & i)
152 |     {
153 |         int v = get();
154 |         if (v == -1) return false;
155 | 
156 |         if (v >= '0' && v <= '9') {
157 |             // 个位数
158 |             i = (int)(v - '0');
159 |             return true;
160 |         }
161 | 
162 |         if (v == TagInteger) {
163 |             // Integer
164 |             std::string const& s = ReadUntil(TagSemicolon);
165 |             i = (int)atoi(s.c_str());
166 |             return true;
167 |         }
168 | 
169 |         if (v == TagLong) {
170 |             // Integer
171 |             std::string const& s = ReadUntil(TagSemicolon);
172 |             i = (long long)atoll(s.c_str());
173 |             return true;
174 |         }
175 | 
176 |         return false;
177 |     }
178 | 
179 |     // double (float)
180 |     template <typename Double>
181 |     typename std::enable_if<std::is_floating_point<Double>::value,
182 |              bool>::type
183 |     Read(Double & f)
184 |     {
185 |         rb_sentry rb(this);
186 |         bool b = __Read(f);
187 |         if (b) rb.commit();
188 |         return b;
189 |     }
190 | 
191 |     template <typename Double>
192 |     typename std::enable_if<std::is_floating_point<Double>::value,
193 |              bool>::type
194 |     __Read(Double & f)
195 |     {
196 |         int v = get();
197 |         if (v == -1) return false;
198 |         if (v == TagNaN) {
199 |             f = std::numeric_limits<Double>::signaling_NaN();
200 |             return true;
201 |         }
202 |         if (v == TagInfinity) {
203 |             int signal = get();
204 |             if (signal == TagPos) {
205 |                 f = std::numeric_limits<Double>::infinity();
206 |                 return true;
207 |             } else if (signal == TagNeg) {
208 |                 f = - std::numeric_limits<Double>::infinity();
209 |                 return true;
210 |             }
211 | 
212 |             return false;
213 |         }
214 |         if (v != TagDouble) return false;
215 |         std::string const& s = ReadUntil(TagSemicolon);
216 |         f = (double)atof(s.c_str());
217 |         return true;
218 |     }
219 | 
220 |     // bool
221 |     bool Read(bool & b)
222 |     {
223 |         rb_sentry rb(this);
224 |         bool r = __Read(b);
225 |         if (r) rb.commit();
226 |         return r;
227 |     }
228 | 
229 |     bool __Read(bool & b)
230 |     {
231 |         int v = get();
232 |         if (v == TagTrue) {
233 |             b = true;
234 |             return true;
235 |         } else if (v == TagFalse) {
236 |             b = false;
237 |             return true;
238 |         }
239 |         return false;
240 |     }
241 | 
242 |     // utf-8 char
243 |     bool ReadUTF8(std::string & c)
244 |     {
245 |         rb_sentry rb(this);
246 |         bool r = __Read(c);
247 |         if (r) rb.commit();
248 |         return r;
249 |     }
250 |     bool __ReadUTF8(std::string & c)
251 |     {
252 |         int v = get();
253 |         if (v != TagUTF8Char) return false;
254 |         int leader = get();
255 |         if (leader == -1) return false;
256 | 
257 |         int follow_bytes = 0;
258 |         for (; follow_bytes <= 6; ++follow_bytes)
259 |             if ((leader & (1 << (7 - follow_bytes))) == 0)
260 |                 break;
261 | 
262 |         std::string r;
263 |         r += leader;
264 |         if (follow_bytes) {
265 |             std::string s = ReadN(follow_bytes);
266 |             if (s.empty()) return false;
267 |             r += s;
268 |             r.swap(c);
269 |             return true;
270 |         }
271 |         return true;
272 |     }
273 | 
274 |     // Null
275 |     bool Read(nullptr_t null)
276 |     {
277 |         rb_sentry rb(this);
278 |         bool r = __Read(null);
279 |         if (r) rb.commit();
280 |         return r;
281 |     }
282 |     bool __Read(nullptr_t null)
283 |     {
284 |         return (get() == TagNull);
285 |     }
286 | 
287 |     // DateTime
288 |     // @returns: local time.
289 |     bool Read(time_t &t, long long &nano)
290 |     {
291 |         rb_sentry rb(this);
292 |         bool r = __Read(t, nano);
293 |         if (r) rb.commit();
294 |         return r;
295 |     }
296 |     bool __Read(time_t &t, long long &nano)
297 |     {
298 |         int v = get();
299 |         if (v == -1) return false;
300 |         if (v != TagDate && v != TagTime) return false;
301 | 
302 |         tm r;
303 |         memset(&r, 0, sizeof(tm));
304 | 
305 |         bool is_utc = false;
306 |         std::string s = ReadUntil(TagSemicolon);
307 |         if (s.empty()) {
308 |             is_utc = true;
309 |             s = ReadUntil(TagUTC);
310 |         }
311 |         if (s.empty()) return false;
312 | 
313 |         if (v == TagDate) {
314 |             // Date
315 |             if (s.size() < 8) return false;
316 |             r.tm_year = atoi(s.substr(0, 4).c_str()) - 1900;
317 |             r.tm_mon = atoi(s.substr(4, 2).c_str());
318 |             r.tm_mday = atoi(s.substr(6, 2).c_str());
319 |             s = s.substr(9);
320 |         } else {
321 |             r.tm_year = 70;
322 |             r.tm_mon = 0;
323 |             r.tm_mday = 1;
324 |         }
325 | 
326 |         if (s.size() >= 6) {
327 |             // Time
328 |             r.tm_hour = atoi(s.substr(0, 2).c_str());
329 |             r.tm_min = atoi(s.substr(2, 4).c_str());
330 |             r.tm_sec = atoi(s.substr(4, 6).c_str());
331 | 
332 |             if (is_utc) {
333 |                 // convert to local time.
334 |                 time_t t = timegm(&r);
335 |                 localtime_r(&t, &r);
336 |             }
337 |             t = mktime(&r);
338 | 
339 |             if (s.size() > 6) {
340 |                 if (s[6] != TagPoint) return false;
341 |                 std::string nanos = s.substr(7);
342 |                 if (nanos.size() > 9) return false;
343 |                 nanos.resize(9, '0');
344 |                 nano = atol(nanos.c_str());
345 |             } else {
346 |                 nano = 0;
347 |             }
348 |         }
349 | 
350 |         return true;
351 |     }
352 | 
353 |     // Bytes & String
354 |     bool Read(std::string & str, bool utf8 = false)
355 |     {
356 |         rb_sentry rb(this);
357 |         bool r = __Read(str);
358 |         if (r) rb.commit();
359 |         return r;
360 |     }
361 |     bool __Read(std::string & str, bool utf8 = false)
362 |     {
363 |         int v = get();
364 |         if (v == TagEmpty) {
365 |             // empty string
366 |             str.clear();
367 |             return true;
368 |         }
369 | 
370 |         if (v != TagString && v != TagBytes) return false;
371 | 
372 |         std::string len_s = ReadUntil(TagQuote);
373 |         if (len_s.empty()) {
374 |             if (get() == TagQuote) {
375 |                 // empty string
376 |                 str.clear();
377 |                 return true;
378 |             }
379 | 
380 |             return false;
381 |         }
382 | 
383 |         std::string result;
384 |         int len = atoi(len_s.c_str());
385 |         if (len <= 0) return false;
386 |         if (utf8) {
387 |             for (int i = 0; i < len; ++i)
388 |             {
389 |                 std::string utf8_char;
390 |                 if (!ReadUTF8(utf8_char))
391 |                     return false;
392 | 
393 |                 result += utf8_char;
394 |             }
395 |         } else {
396 |             std::string bin = ReadN(len);
397 |             if (bin.length() != (size_t)len) return false;
398 |             result.swap(bin);
399 |         }
400 | 
401 |         if (get() == TagQuote) {
402 |             str.swap(result);
403 |             return true;
404 |         }
405 | 
406 |         return false;
407 |     }
408 | 
409 |     bool Read(boost::uuids::uuid & uuid)
410 |     {
411 |         rb_sentry rb(this);
412 |         bool r = __Read(uuid);
413 |         if (r) rb.commit();
414 |         return r;
415 |     }
416 |     bool __Read(boost::uuids::uuid & uuid)
417 |     {
418 |         if (get() != TagGuid) return false;
419 |         if (get() != TagOpenbrace) return false;
420 |         std::string uuid_s = ReadUntil(TagClosebrace);
421 |         if (uuid_s.empty()) return false;
422 |         try {
423 |             boost::uuids::uuid n_uuid;
424 |             n_uuid = boost::uuids::string_generator()(uuid_s);
425 |             n_uuid.swap(uuid);
426 |             return true;
427 |         } catch (std::exception &e) {
428 |             return false;
429 |         }
430 |     }
431 | 
432 |     // std::map & std::unordered_map
433 |     // @remarks: use container by iterator.
434 |     template <typename Container>
435 |     typename std::enable_if<has_mapped_type<Container>::value, bool>::type
436 |     Read(Container & container)
437 |     {
438 |         rb_sentry rb(this);
439 |         bool r = __Read(container);
440 |         if (r) rb.commit();
441 |         return r;
442 |     }
443 |     template <typename Container>
444 |     typename std::enable_if<has_mapped_type<Container>::value, bool>::type
445 |     __Read(Container & container)
446 |     {
447 | //        static_assert(false, "No support map.");
448 |         return false;
449 |     }
450 | 
451 |     // std::vector & std::list & std::array & std::deque & std::set
452 |     // @remarks: use container by iterator.
453 |     template <typename Container>
454 |     typename std::enable_if<!has_mapped_type<Container>::value && !std::is_integral<Container>::value,
455 |              bool>::type
456 |     Read(Container & container)
457 |     {
458 |         rb_sentry rb(this);
459 |         bool r = __Read(container);
460 |         if (r) rb.commit();
461 |         return r;
462 |     }
463 | 
464 |     template <typename Container>
465 |     typename std::enable_if<!has_mapped_type<Container>::value && !std::is_integral<Container>::value,
466 |              bool>::type
467 |     __Read(Container & container)
468 |     {
469 |         if (get() != TagList) return false;
470 |         std::string len_s = ReadUntil(TagOpenbrace);
471 |         if (len_s.empty()) {
472 |             if (get() == TagClosebrace) {
473 |                 container.clear();
474 |                 return true;
475 |             }
476 | 
477 |             return false;
478 |         }
479 | 
480 |         int len = atoi(len_s.c_str());
481 |         Container c;
482 |         c.resize(len);
483 |         for (auto & elem : c)
484 |             if (!this->Read(elem))
485 |                 return false;
486 | 
487 |         if (get() == TagClosebrace) {
488 |             container.swap(c);
489 |             return true;
490 |         }
491 | 
492 |         return false;
493 |     }
494 | 
495 |     ///////////////////////////////////////////////////////////////
496 |     // integer and long
497 |     void __Write(std::string const& s)
498 |     {
499 |         s_ += s;
500 |     }
501 | 
502 |     void __Write(char c)
503 |     {
504 |         s_ += c;
505 |     }
506 | 
507 |     void Write(char c)
508 |     {
509 |         s_ += c;
510 |     }
511 | 
512 |     template <typename Integer>
513 |     typename std::enable_if<std::is_integral<Integer>::value && !std::is_same<Integer, bool>::value>::type
514 |     Write(Integer i)
515 |     {
516 |         if (i >= 0 && i <= 9) {
517 |             Write((char)(i + '0'));
518 |             return ;
519 |         }
520 | 
521 |         __Write(sizeof(Integer) <= 4 ? TagInteger : TagLong);
522 |         __Write(std::to_string(i));
523 |         __Write(TagSemicolon);
524 |     }
525 | 
526 |     // double (float)
527 |     template <typename Double>
528 |     typename std::enable_if<std::is_floating_point<Double>::value>::type
529 |     Write(Double f)
530 |     {
531 |         typedef typename std::conditional<sizeof(Double) == 4, int32_t, int64_t>::type CInteger;
532 |         static const Double nan = std::numeric_limits<Double>::signaling_NaN();
533 |         if (*(CInteger*)&f == *(CInteger*)&nan) {
534 |             __Write(TagNaN);
535 |             return ;
536 |         }
537 | 
538 |         static const Double inf = std::numeric_limits<Double>::infinity();
539 |         if (*(CInteger*)&f == *(CInteger*)&inf) {
540 |             __Write(TagInfinity);
541 |             __Write(TagPos);
542 |             return ;
543 |         }
544 | 
545 |         static const Double negative_inf = std::numeric_limits<Double>::infinity();
546 |         if (*(CInteger*)&f == *(CInteger*)&negative_inf) {
547 |             __Write(TagInfinity);
548 |             __Write(TagNeg);
549 |             return ;
550 |         }
551 | 
552 |         __Write(TagDouble);
553 |         __Write(std::to_string(f));
554 |         __Write(TagSemicolon);
555 |     }
556 | 
557 |     // bool
558 |     void Write(bool b)
559 |     {
560 |         __Write(b ? TagTrue : TagFalse);
561 |     }
562 | 
563 |     // utf-8 char
564 |     void WriteUTF8(std::string const& c)
565 |     {
566 |         __Write(TagUTF8Char);
567 |         __Write(c);
568 |     }
569 | 
570 |     // Null
571 |     void Write(nullptr_t null)
572 |     {
573 |         __Write(TagNull);
574 |     }
575 | 
576 |     // DateTime
577 |     // @returns: local time.
578 |     void Write(time_t t, long long nano)
579 |     {
580 |         // TODO
581 |     }
582 | 
583 |     // Bytes & String
584 |     int utf8_char_count(std::string const& str)
585 |     {
586 |         int chars = 0;
587 |         for (size_t i = 0; i < str.length(); ++i, ++chars)
588 |         {
589 |             char leader = str[i];
590 |             int follow_bytes = 0;
591 |             for (; follow_bytes <= 6; ++follow_bytes)
592 |                 if ((leader & (1 << (7 - follow_bytes))) == 0)
593 |                     break;
594 |             i += follow_bytes;
595 |         }
596 |         return chars;
597 |     }
598 |     void Write(std::string const& str, bool utf8 = false)
599 |     {
600 |         if (str.empty()) {
601 |             __Write(TagEmpty);
602 |             return ;
603 |         }
604 | 
605 |         __Write(utf8 ? TagString : TagBytes);
606 |         int len = utf8 ? utf8_char_count(str) : str.length();
607 |         __Write(std::to_string(len));
608 |         __Write(TagQuote);
609 |         __Write(str);
610 |         __Write(TagQuote);
611 |     }
612 |     void Write(const char* sstr, bool utf8 = false)
613 |     {
614 |         Write(std::string(sstr), utf8);
615 |     }
616 | 
617 |     void Write(boost::uuids::uuid const& uuid)
618 |     {
619 |     }
620 | 
621 |     // std::map & std::unordered_map
622 |     // @remarks: use container by iterator.
623 |     template <typename Container>
624 |     typename std::enable_if<has_mapped_type<Container>::value>::type
625 |     Write(Container const& container)
626 |     {
627 |         // TODO
628 |     }
629 | 
630 |     // std::vector & std::list & std::array & std::deque & std::set
631 |     // @remarks: use container by iterator.
632 |     template <typename Container>
633 |     typename std::enable_if<!has_mapped_type<Container>::value && !std::is_integral<Container>::value>::type
634 |     Write(Container const& container)
635 |     {
636 |         __Write(TagList);
637 |         if (container.size() == 0) {
638 |             __Write(TagOpenbrace);
639 |             __Write(TagClosebrace);
640 |             return ;
641 |         }
642 | 
643 |         __Write(std::to_string(container.size()));
644 |         __Write(TagOpenbrace);
645 |         for (auto &elem : container)
646 |             Write(elem);
647 |         __Write(TagClosebrace);
648 |     }
649 | 
650 | };
651 | 
652 | } // namespace hprose
653 | } // namespace ucorf
654 | 
655 | 


--------------------------------------------------------------------------------
/proto_gen/descriptor.proto:
--------------------------------------------------------------------------------
  1 | // Protocol Buffers - Google's data interchange format
  2 | // Copyright 2008 Google Inc.  All rights reserved.
  3 | // http://code.google.com/p/protobuf/
  4 | //
  5 | // Redistribution and use in source and binary forms, with or without
  6 | // modification, are permitted provided that the following conditions are
  7 | // met:
  8 | //
  9 | //     * Redistributions of source code must retain the above copyright
 10 | // notice, this list of conditions and the following disclaimer.
 11 | //     * Redistributions in binary form must reproduce the above
 12 | // copyright notice, this list of conditions and the following disclaimer
 13 | // in the documentation and/or other materials provided with the
 14 | // distribution.
 15 | //     * Neither the name of Google Inc. nor the names of its
 16 | // contributors may be used to endorse or promote products derived from
 17 | // this software without specific prior written permission.
 18 | //
 19 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 20 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 21 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 22 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 23 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 24 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 25 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 26 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 27 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 28 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 29 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 30 | 
 31 | // Author: kenton@google.com (Kenton Varda)
 32 | //  Based on original Protocol Buffers design by
 33 | //  Sanjay Ghemawat, Jeff Dean, and others.
 34 | //
 35 | // The messages in this file describe the definitions found in .proto files.
 36 | // A valid .proto file can be translated directly to a FileDescriptorProto
 37 | // without any other information (e.g. without reading its imports).
 38 | 
 39 | 
 40 | 
 41 | package google.protobuf;
 42 | option java_package = "com.google.protobuf";
 43 | option java_outer_classname = "DescriptorProtos";
 44 | 
 45 | // descriptor.proto must be optimized for speed because reflection-based
 46 | // algorithms don't work during bootstrapping.
 47 | option optimize_for = SPEED;
 48 | 
 49 | // The protocol compiler can output a FileDescriptorSet containing the .proto
 50 | // files it parses.
 51 | message FileDescriptorSet {
 52 |   repeated FileDescriptorProto file = 1;
 53 | }
 54 | 
 55 | // Describes a complete .proto file.
 56 | message FileDescriptorProto {
 57 |   optional string name = 1;       // file name, relative to root of source tree
 58 |   optional string package = 2;    // e.g. "foo", "foo.bar", etc.
 59 | 
 60 |   // Names of files imported by this file.
 61 |   repeated string dependency = 3;
 62 |   // Indexes of the public imported files in the dependency list above.
 63 |   repeated int32 public_dependency = 10;
 64 |   // Indexes of the weak imported files in the dependency list.
 65 |   // For Google-internal migration only. Do not use.
 66 |   repeated int32 weak_dependency = 11;
 67 | 
 68 |   // All top-level definitions in this file.
 69 |   repeated DescriptorProto message_type = 4;
 70 |   repeated EnumDescriptorProto enum_type = 5;
 71 |   repeated ServiceDescriptorProto service = 6;
 72 |   repeated FieldDescriptorProto extension = 7;
 73 | 
 74 |   optional FileOptions options = 8;
 75 | 
 76 |   // This field contains optional information about the original source code.
 77 |   // You may safely remove this entire field whithout harming runtime
 78 |   // functionality of the descriptors -- the information is needed only by
 79 |   // development tools.
 80 |   optional SourceCodeInfo source_code_info = 9;
 81 | }
 82 | 
 83 | // Describes a message type.
 84 | message DescriptorProto {
 85 |   optional string name = 1;
 86 | 
 87 |   repeated FieldDescriptorProto field = 2;
 88 |   repeated FieldDescriptorProto extension = 6;
 89 | 
 90 |   repeated DescriptorProto nested_type = 3;
 91 |   repeated EnumDescriptorProto enum_type = 4;
 92 | 
 93 |   message ExtensionRange {
 94 |     optional int32 start = 1;
 95 |     optional int32 end = 2;
 96 |   }
 97 |   repeated ExtensionRange extension_range = 5;
 98 | 
 99 |   optional MessageOptions options = 7;
100 | }
101 | 
102 | // Describes a field within a message.
103 | message FieldDescriptorProto {
104 |   enum Type {
105 |     // 0 is reserved for errors.
106 |     // Order is weird for historical reasons.
107 |     TYPE_DOUBLE         = 1;
108 |     TYPE_FLOAT          = 2;
109 |     // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
110 |     // negative values are likely.
111 |     TYPE_INT64          = 3;
112 |     TYPE_UINT64         = 4;
113 |     // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
114 |     // negative values are likely.
115 |     TYPE_INT32          = 5;
116 |     TYPE_FIXED64        = 6;
117 |     TYPE_FIXED32        = 7;
118 |     TYPE_BOOL           = 8;
119 |     TYPE_STRING         = 9;
120 |     TYPE_GROUP          = 10;  // Tag-delimited aggregate.
121 |     TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
122 | 
123 |     // New in version 2.
124 |     TYPE_BYTES          = 12;
125 |     TYPE_UINT32         = 13;
126 |     TYPE_ENUM           = 14;
127 |     TYPE_SFIXED32       = 15;
128 |     TYPE_SFIXED64       = 16;
129 |     TYPE_SINT32         = 17;  // Uses ZigZag encoding.
130 |     TYPE_SINT64         = 18;  // Uses ZigZag encoding.
131 |   };
132 | 
133 |   enum Label {
134 |     // 0 is reserved for errors
135 |     LABEL_OPTIONAL      = 1;
136 |     LABEL_REQUIRED      = 2;
137 |     LABEL_REPEATED      = 3;
138 |     // TODO(sanjay): Should we add LABEL_MAP?
139 |   };
140 | 
141 |   optional string name = 1;
142 |   optional int32 number = 3;
143 |   optional Label label = 4;
144 | 
145 |   // If type_name is set, this need not be set.  If both this and type_name
146 |   // are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
147 |   optional Type type = 5;
148 | 
149 |   // For message and enum types, this is the name of the type.  If the name
150 |   // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
151 |   // rules are used to find the type (i.e. first the nested types within this
152 |   // message are searched, then within the parent, on up to the root
153 |   // namespace).
154 |   optional string type_name = 6;
155 | 
156 |   // For extensions, this is the name of the type being extended.  It is
157 |   // resolved in the same manner as type_name.
158 |   optional string extendee = 2;
159 | 
160 |   // For numeric types, contains the original text representation of the value.
161 |   // For booleans, "true" or "false".
162 |   // For strings, contains the default text contents (not escaped in any way).
163 |   // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
164 |   // TODO(kenton):  Base-64 encode?
165 |   optional string default_value = 7;
166 | 
167 |   optional FieldOptions options = 8;
168 | }
169 | 
170 | // Describes an enum type.
171 | message EnumDescriptorProto {
172 |   optional string name = 1;
173 | 
174 |   repeated EnumValueDescriptorProto value = 2;
175 | 
176 |   optional EnumOptions options = 3;
177 | }
178 | 
179 | // Describes a value within an enum.
180 | message EnumValueDescriptorProto {
181 |   optional string name = 1;
182 |   optional int32 number = 2;
183 | 
184 |   optional EnumValueOptions options = 3;
185 | }
186 | 
187 | // Describes a service.
188 | message ServiceDescriptorProto {
189 |   optional string name = 1;
190 |   repeated MethodDescriptorProto method = 2;
191 | 
192 |   optional ServiceOptions options = 3;
193 | }
194 | 
195 | // Describes a method of a service.
196 | message MethodDescriptorProto {
197 |   optional string name = 1;
198 | 
199 |   // Input and output type names.  These are resolved in the same way as
200 |   // FieldDescriptorProto.type_name, but must refer to a message type.
201 |   optional string input_type = 2;
202 |   optional string output_type = 3;
203 | 
204 |   optional MethodOptions options = 4;
205 | }
206 | 
207 | 
208 | // ===================================================================
209 | // Options
210 | 
211 | // Each of the definitions above may have "options" attached.  These are
212 | // just annotations which may cause code to be generated slightly differently
213 | // or may contain hints for code that manipulates protocol messages.
214 | //
215 | // Clients may define custom options as extensions of the *Options messages.
216 | // These extensions may not yet be known at parsing time, so the parser cannot
217 | // store the values in them.  Instead it stores them in a field in the *Options
218 | // message called uninterpreted_option. This field must have the same name
219 | // across all *Options messages. We then use this field to populate the
220 | // extensions when we build a descriptor, at which point all protos have been
221 | // parsed and so all extensions are known.
222 | //
223 | // Extension numbers for custom options may be chosen as follows:
224 | // * For options which will only be used within a single application or
225 | //   organization, or for experimental options, use field numbers 50000
226 | //   through 99999.  It is up to you to ensure that you do not use the
227 | //   same number for multiple options.
228 | // * For options which will be published and used publicly by multiple
229 | //   independent entities, e-mail protobuf-global-extension-registry@google.com
230 | //   to reserve extension numbers. Simply provide your project name (e.g.
231 | //   Object-C plugin) and your porject website (if available) -- there's no need
232 | //   to explain how you intend to use them. Usually you only need one extension
233 | //   number. You can declare multiple options with only one extension number by
234 | //   putting them in a sub-message. See the Custom Options section of the docs
235 | //   for examples:
236 | //   http://code.google.com/apis/protocolbuffers/docs/proto.html#options
237 | //   If this turns out to be popular, a web service will be set up
238 | //   to automatically assign option numbers.
239 | 
240 | 
241 | message FileOptions {
242 | 
243 |   // Sets the Java package where classes generated from this .proto will be
244 |   // placed.  By default, the proto package is used, but this is often
245 |   // inappropriate because proto packages do not normally start with backwards
246 |   // domain names.
247 |   optional string java_package = 1;
248 | 
249 | 
250 |   // If set, all the classes from the .proto file are wrapped in a single
251 |   // outer class with the given name.  This applies to both Proto1
252 |   // (equivalent to the old "--one_java_file" option) and Proto2 (where
253 |   // a .proto always translates to a single class, but you may want to
254 |   // explicitly choose the class name).
255 |   optional string java_outer_classname = 8;
256 | 
257 |   // If set true, then the Java code generator will generate a separate .java
258 |   // file for each top-level message, enum, and service defined in the .proto
259 |   // file.  Thus, these types will *not* be nested inside the outer class
260 |   // named by java_outer_classname.  However, the outer class will still be
261 |   // generated to contain the file's getDescriptor() method as well as any
262 |   // top-level extensions defined in the file.
263 |   optional bool java_multiple_files = 10 [default=false];
264 | 
265 |   // If set true, then the Java code generator will generate equals() and
266 |   // hashCode() methods for all messages defined in the .proto file. This is
267 |   // purely a speed optimization, as the AbstractMessage base class includes
268 |   // reflection-based implementations of these methods.
269 |   optional bool java_generate_equals_and_hash = 20 [default=false];
270 | 
271 |   // Generated classes can be optimized for speed or code size.
272 |   enum OptimizeMode {
273 |     SPEED = 1;        // Generate complete code for parsing, serialization,
274 |                       // etc.
275 |     CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
276 |     LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
277 |   }
278 |   optional OptimizeMode optimize_for = 9 [default=SPEED];
279 | 
280 |   // Sets the Go package where structs generated from this .proto will be
281 |   // placed.  There is no default.
282 |   optional string go_package = 11;
283 | 
284 | 
285 | 
286 |   // Should generic services be generated in each language?  "Generic" services
287 |   // are not specific to any particular RPC system.  They are generated by the
288 |   // main code generators in each language (without additional plugins).
289 |   // Generic services were the only kind of service generation supported by
290 |   // early versions of proto2.
291 |   //
292 |   // Generic services are now considered deprecated in favor of using plugins
293 |   // that generate code specific to your particular RPC system.  Therefore,
294 |   // these default to false.  Old code which depends on generic services should
295 |   // explicitly set them to true.
296 |   optional bool cc_generic_services = 16 [default=false];
297 |   optional bool java_generic_services = 17 [default=false];
298 |   optional bool py_generic_services = 18 [default=false];
299 | 
300 |   // The parser stores options it doesn't recognize here. See above.
301 |   repeated UninterpretedOption uninterpreted_option = 999;
302 | 
303 |   // Clients can define custom options in extensions of this message. See above.
304 |   extensions 1000 to max;
305 | }
306 | 
307 | message MessageOptions {
308 |   // Set true to use the old proto1 MessageSet wire format for extensions.
309 |   // This is provided for backwards-compatibility with the MessageSet wire
310 |   // format.  You should not use this for any other reason:  It's less
311 |   // efficient, has fewer features, and is more complicated.
312 |   //
313 |   // The message must be defined exactly as follows:
314 |   //   message Foo {
315 |   //     option message_set_wire_format = true;
316 |   //     extensions 4 to max;
317 |   //   }
318 |   // Note that the message cannot have any defined fields; MessageSets only
319 |   // have extensions.
320 |   //
321 |   // All extensions of your type must be singular messages; e.g. they cannot
322 |   // be int32s, enums, or repeated messages.
323 |   //
324 |   // Because this is an option, the above two restrictions are not enforced by
325 |   // the protocol compiler.
326 |   optional bool message_set_wire_format = 1 [default=false];
327 | 
328 |   // Disables the generation of the standard "descriptor()" accessor, which can
329 |   // conflict with a field of the same name.  This is meant to make migration
330 |   // from proto1 easier; new code should avoid fields named "descriptor".
331 |   optional bool no_standard_descriptor_accessor = 2 [default=false];
332 | 
333 |   // The parser stores options it doesn't recognize here. See above.
334 |   repeated UninterpretedOption uninterpreted_option = 999;
335 | 
336 |   // Clients can define custom options in extensions of this message. See above.
337 |   extensions 1000 to max;
338 | }
339 | 
340 | message FieldOptions {
341 |   // The ctype option instructs the C++ code generator to use a different
342 |   // representation of the field than it normally would.  See the specific
343 |   // options below.  This option is not yet implemented in the open source
344 |   // release -- sorry, we'll try to include it in a future version!
345 |   optional CType ctype = 1 [default = STRING];
346 |   enum CType {
347 |     // Default mode.
348 |     STRING = 0;
349 | 
350 |     CORD = 1;
351 | 
352 |     STRING_PIECE = 2;
353 |   }
354 |   // The packed option can be enabled for repeated primitive fields to enable
355 |   // a more efficient representation on the wire. Rather than repeatedly
356 |   // writing the tag and type for each element, the entire array is encoded as
357 |   // a single length-delimited blob.
358 |   optional bool packed = 2;
359 | 
360 | 
361 | 
362 |   // Should this field be parsed lazily?  Lazy applies only to message-type
363 |   // fields.  It means that when the outer message is initially parsed, the
364 |   // inner message's contents will not be parsed but instead stored in encoded
365 |   // form.  The inner message will actually be parsed when it is first accessed.
366 |   //
367 |   // This is only a hint.  Implementations are free to choose whether to use
368 |   // eager or lazy parsing regardless of the value of this option.  However,
369 |   // setting this option true suggests that the protocol author believes that
370 |   // using lazy parsing on this field is worth the additional bookkeeping
371 |   // overhead typically needed to implement it.
372 |   //
373 |   // This option does not affect the public interface of any generated code;
374 |   // all method signatures remain the same.  Furthermore, thread-safety of the
375 |   // interface is not affected by this option; const methods remain safe to
376 |   // call from multiple threads concurrently, while non-const methods continue
377 |   // to require exclusive access.
378 |   //
379 |   //
380 |   // Note that implementations may choose not to check required fields within
381 |   // a lazy sub-message.  That is, calling IsInitialized() on the outher message
382 |   // may return true even if the inner message has missing required fields.
383 |   // This is necessary because otherwise the inner message would have to be
384 |   // parsed in order to perform the check, defeating the purpose of lazy
385 |   // parsing.  An implementation which chooses not to check required fields
386 |   // must be consistent about it.  That is, for any particular sub-message, the
387 |   // implementation must either *always* check its required fields, or *never*
388 |   // check its required fields, regardless of whether or not the message has
389 |   // been parsed.
390 |   optional bool lazy = 5 [default=false];
391 | 
392 |   // Is this field deprecated?
393 |   // Depending on the target platform, this can emit Deprecated annotations
394 |   // for accessors, or it will be completely ignored; in the very least, this
395 |   // is a formalization for deprecating fields.
396 |   optional bool deprecated = 3 [default=false];
397 | 
398 |   // EXPERIMENTAL.  DO NOT USE.
399 |   // For "map" fields, the name of the field in the enclosed type that
400 |   // is the key for this map.  For example, suppose we have:
401 |   //   message Item {
402 |   //     required string name = 1;
403 |   //     required string value = 2;
404 |   //   }
405 |   //   message Config {
406 |   //     repeated Item items = 1 [experimental_map_key="name"];
407 |   //   }
408 |   // In this situation, the map key for Item will be set to "name".
409 |   // TODO: Fully-implement this, then remove the "experimental_" prefix.
410 |   optional string experimental_map_key = 9;
411 | 
412 |   // For Google-internal migration only. Do not use.
413 |   optional bool weak = 10 [default=false];
414 | 
415 |   // The parser stores options it doesn't recognize here. See above.
416 |   repeated UninterpretedOption uninterpreted_option = 999;
417 | 
418 |   // Clients can define custom options in extensions of this message. See above.
419 |   extensions 1000 to max;
420 | }
421 | 
422 | message EnumOptions {
423 | 
424 |   // Set this option to false to disallow mapping different tag names to a same
425 |   // value.
426 |   optional bool allow_alias = 2 [default=true];
427 | 
428 |   // The parser stores options it doesn't recognize here. See above.
429 |   repeated UninterpretedOption uninterpreted_option = 999;
430 | 
431 |   // Clients can define custom options in extensions of this message. See above.
432 |   extensions 1000 to max;
433 | }
434 | 
435 | message EnumValueOptions {
436 |   // The parser stores options it doesn't recognize here. See above.
437 |   repeated UninterpretedOption uninterpreted_option = 999;
438 | 
439 |   // Clients can define custom options in extensions of this message. See above.
440 |   extensions 1000 to max;
441 | }
442 | 
443 | message ServiceOptions {
444 | 
445 |   // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
446 |   //   framework.  We apologize for hoarding these numbers to ourselves, but
447 |   //   we were already using them long before we decided to release Protocol
448 |   //   Buffers.
449 | 
450 |   // The parser stores options it doesn't recognize here. See above.
451 |   repeated UninterpretedOption uninterpreted_option = 999;
452 | 
453 |   // Clients can define custom options in extensions of this message. See above.
454 |   extensions 1000 to max;
455 | }
456 | 
457 | message MethodOptions {
458 | 
459 |   // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
460 |   //   framework.  We apologize for hoarding these numbers to ourselves, but
461 |   //   we were already using them long before we decided to release Protocol
462 |   //   Buffers.
463 | 
464 |   // The parser stores options it doesn't recognize here. See above.
465 |   repeated UninterpretedOption uninterpreted_option = 999;
466 | 
467 |   // Clients can define custom options in extensions of this message. See above.
468 |   extensions 1000 to max;
469 | }
470 | 
471 | 
472 | // A message representing a option the parser does not recognize. This only
473 | // appears in options protos created by the compiler::Parser class.
474 | // DescriptorPool resolves these when building Descriptor objects. Therefore,
475 | // options protos in descriptor objects (e.g. returned by Descriptor::options(),
476 | // or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
477 | // in them.
478 | message UninterpretedOption {
479 |   // The name of the uninterpreted option.  Each string represents a segment in
480 |   // a dot-separated name.  is_extension is true iff a segment represents an
481 |   // extension (denoted with parentheses in options specs in .proto files).
482 |   // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
483 |   // "foo.(bar.baz).qux".
484 |   message NamePart {
485 |     required string name_part = 1;
486 |     required bool is_extension = 2;
487 |   }
488 |   repeated NamePart name = 2;
489 | 
490 |   // The value of the uninterpreted option, in whatever type the tokenizer
491 |   // identified it as during parsing. Exactly one of these should be set.
492 |   optional string identifier_value = 3;
493 |   optional uint64 positive_int_value = 4;
494 |   optional int64 negative_int_value = 5;
495 |   optional double double_value = 6;
496 |   optional bytes string_value = 7;
497 |   optional string aggregate_value = 8;
498 | }
499 | 
500 | // ===================================================================
501 | // Optional source code info
502 | 
503 | // Encapsulates information about the original source file from which a
504 | // FileDescriptorProto was generated.
505 | message SourceCodeInfo {
506 |   // A Location identifies a piece of source code in a .proto file which
507 |   // corresponds to a particular definition.  This information is intended
508 |   // to be useful to IDEs, code indexers, documentation generators, and similar
509 |   // tools.
510 |   //
511 |   // For example, say we have a file like:
512 |   //   message Foo {
513 |   //     optional string foo = 1;
514 |   //   }
515 |   // Let's look at just the field definition:
516 |   //   optional string foo = 1;
517 |   //   ^       ^^     ^^  ^  ^^^
518 |   //   a       bc     de  f  ghi
519 |   // We have the following locations:
520 |   //   span   path               represents
521 |   //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
522 |   //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
523 |   //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
524 |   //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
525 |   //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
526 |   //
527 |   // Notes:
528 |   // - A location may refer to a repeated field itself (i.e. not to any
529 |   //   particular index within it).  This is used whenever a set of elements are
530 |   //   logically enclosed in a single code segment.  For example, an entire
531 |   //   extend block (possibly containing multiple extension definitions) will
532 |   //   have an outer location whose path refers to the "extensions" repeated
533 |   //   field without an index.
534 |   // - Multiple locations may have the same path.  This happens when a single
535 |   //   logical declaration is spread out across multiple places.  The most
536 |   //   obvious example is the "extend" block again -- there may be multiple
537 |   //   extend blocks in the same scope, each of which will have the same path.
538 |   // - A location's span is not always a subset of its parent's span.  For
539 |   //   example, the "extendee" of an extension declaration appears at the
540 |   //   beginning of the "extend" block and is shared by all extensions within
541 |   //   the block.
542 |   // - Just because a location's span is a subset of some other location's span
543 |   //   does not mean that it is a descendent.  For example, a "group" defines
544 |   //   both a type and a field in a single declaration.  Thus, the locations
545 |   //   corresponding to the type and field and their components will overlap.
546 |   // - Code which tries to interpret locations should probably be designed to
547 |   //   ignore those that it doesn't understand, as more types of locations could
548 |   //   be recorded in the future.
549 |   repeated Location location = 1;
550 |   message Location {
551 |     // Identifies which part of the FileDescriptorProto was defined at this
552 |     // location.
553 |     //
554 |     // Each element is a field number or an index.  They form a path from
555 |     // the root FileDescriptorProto to the place where the definition.  For
556 |     // example, this path:
557 |     //   [ 4, 3, 2, 7, 1 ]
558 |     // refers to:
559 |     //   file.message_type(3)  // 4, 3
560 |     //       .field(7)         // 2, 7
561 |     //       .name()           // 1
562 |     // This is because FileDescriptorProto.message_type has field number 4:
563 |     //   repeated DescriptorProto message_type = 4;
564 |     // and DescriptorProto.field has field number 2:
565 |     //   repeated FieldDescriptorProto field = 2;
566 |     // and FieldDescriptorProto.name has field number 1:
567 |     //   optional string name = 1;
568 |     //
569 |     // Thus, the above path gives the location of a field name.  If we removed
570 |     // the last element:
571 |     //   [ 4, 3, 2, 7 ]
572 |     // this path refers to the whole field declaration (from the beginning
573 |     // of the label to the terminating semicolon).
574 |     repeated int32 path = 1 [packed=true];
575 | 
576 |     // Always has exactly three or four elements: start line, start column,
577 |     // end line (optional, otherwise assumed same as start line), end column.
578 |     // These are packed into a single field for efficiency.  Note that line
579 |     // and column numbers are zero-based -- typically you will want to add
580 |     // 1 to each before displaying to a user.
581 |     repeated int32 span = 2 [packed=true];
582 | 
583 |     // If this SourceCodeInfo represents a complete declaration, these are any
584 |     // comments appearing before and after the declaration which appear to be
585 |     // attached to the declaration.
586 |     //
587 |     // A series of line comments appearing on consecutive lines, with no other
588 |     // tokens appearing on those lines, will be treated as a single comment.
589 |     //
590 |     // Only the comment content is provided; comment markers (e.g. //) are
591 |     // stripped out.  For block comments, leading whitespace and an asterisk
592 |     // will be stripped from the beginning of each line other than the first.
593 |     // Newlines are included in the output.
594 |     //
595 |     // Examples:
596 |     //
597 |     //   optional int32 foo = 1;  // Comment attached to foo.
598 |     //   // Comment attached to bar.
599 |     //   optional int32 bar = 2;
600 |     //
601 |     //   optional string baz = 3;
602 |     //   // Comment attached to baz.
603 |     //   // Another line attached to baz.
604 |     //
605 |     //   // Comment attached to qux.
606 |     //   //
607 |     //   // Another line attached to qux.
608 |     //   optional double qux = 4;
609 |     //
610 |     //   optional string corge = 5;
611 |     //   /* Block comment attached
612 |     //    * to corge.  Leading asterisks
613 |     //    * will be removed. */
614 |     //   /* Block comment attached to
615 |     //    * grault. */
616 |     //   optional int32 grault = 6;
617 |     optional string leading_comments = 3;
618 |     optional string trailing_comments = 4;
619 |   }
620 | }
621 | 


--------------------------------------------------------------------------------