Project: SRPC (Orchestration & Management / Remote Procedure Call)
File: README.md

``` git clone https://github.com/sogou/srpc cd srpc/tools make ``` ``` ./srpc ``` ``` Description: Simple generator for building Workflow and SRPC projects. Usage: ./srpc <COMMAND> <PROJECT_NAME> [FLAGS] Available Commands: http - create project with both client and server redis - create project with both client and server rpc - create project with both client and server proxy - create proxy for some client and server protocol file - create project with asynchronous file service compute - create project with asynchronous computing service ``` Execute this simple example: ```sh ./srpc http project_name1 ``` And we will get this on the screen, new project is in `./project_name1/`. ``` Success: make project path " ./project_name1/ " done. Commands: cd ./project_name1/ make -j Execute: ./server ./client ``` Let's take a look at the project: ``` cd ./project_name1/ && tree ``` These files are generated. ``` . CMakeLists.txt GNUmakefile client.conf client_main.cc config Json.cc Json.h config.cc config.h util.h full.conf server.conf server_main.cc 2 directories, 12 files ``` And we can try to make the project accorrding to the suggestions above. commands for HTTP: ``` ./srpc http ``` will get the following instructions: ``` Missing: PROJECT_NAME Usage: ./srpc http <PROJECT_NAME> [FLAGS] Example: ./srpc redis myhttpproject Available Flags: -o : project output path (default: CURRENT_PATH) -d : path of dependencies (default: COMPILE_PATH) ``` commands for RPCs: ``` ./srpc rpc ``` will get the following instructions: ``` Missing: PROJECT_NAME Usage: ./srpc rpc <PROJECT_NAME> [FLAGS] Example: ./srpc redis myrpcproject Available Flags: -r : rpc type [ SRPC | SRPCHttp | BRPC | Thrift | ThriftHttp | TRPC | TRPCHttp ] (default: SRPC) -o : project output path (default: CURRENT_PATH) -s : service name (default: PROJECT_NAME) -i : idl type [ protobuf | thrift ] (default: protobuf) -x : data type [ protobuf | thrift | json ] (default: idl type. json for http) -c : compress type [ gzip | zlib | snappy | lz4 ] (default: no compression) -d : path of dependencies (default: COMPILE_PATH) -f : specify the idlfile to generate codes (default: template/rpc/IDLFILE) -p : specify the path for idl_file to depend (default: template/rpc/) ``` We can specified our IDL files with the following command: ``` ./srpc rpc rpcexample -f testproto/test.proto ``` And we can see the infomation when generating files, which is similar to srpc_genrator. ``` Info: srpc generator begin. proto file: [/root/srpc/tools/rpc_example/test.proto] Successfully parse service block [message] : EchoRequest Successfully parse service block [message] : EchoResponse Successfully parse service block [service] : new_test Successfully parse method:Echo req:EchoRequest resp:EchoResponse finish parsing proto file: [/root/srpc/tools/rpc_example/test.proto] [Generator] generate srpc files: /root/srpc/tools/rpc_example/test.srpc.h [Generator Done] [Generator] generate server files: /root/srpc/tools/rpcexample/servermain.cc, client files: /root/srpc/tools/rpcexample/clientmain.cc Info: srpc generator done. Success: make project path " /root/srpc/tools/rpc_example/ " done. Commands: cd /root/srpc/tools/rpc_example/ make -j Execute: ./server ./client ``` This command is to create an IDL file, which is convenient for us to create rpc project after changing the file. The command is as follows: ``` Missing: FILE_NAME Usage: ./srpc api <FILE_NAME> [FLAGS] Example:

api my_api Available Flags: -o : file output path (default: CURRENT_PATH) -i : idl type [ protobuf | thrift ] (default: protobuf) ``` Create a file in proto format by default: ``` ./srpc api test ``` ``` Success: Create api file test.proto at path /root/srpc/tools done. Suggestions: Modify the api file as you needed. And make rpc project base on this file with the following command: ./srpc rpc myrpcproject -f test.proto -p /root/srpc/tools ``` Then we can create an rpc project through the above suggested commands. The rpc project uses the test.proto file to create the generated code. commands for REDIS: ``` ./srpc redis ``` will get the following instructions: ``` Missing: PROJECT_NAME Usage: ./srpc redis <PROJECT_NAME> [FLAGS] Example: ./srpc redis myredisproject Available Flags: -o : project output path (default: CURRENT_PATH) -d : path of dependencies (default: COMPILE_PATH) ``` Make a project with the instructions, we can get the simple redis server and client. The client will send a basic command `SET k1 v1`, and the server will reply `OK` for every request. ``` ./server Redis server started, port 6379 redis server get cmd: [SET] from peer address: 127.0.0.1:60665, seq: 0. ``` ``` ./client Redis client state = 0 error = 0 response: OK ``` If there is user name and password for redis server, client may fill them into client.conf: ``` 1 { 2 "client": 3 { 4 "remote_host": "127.0.0.1", 5 "remote_port": 6379, 6 "retry_max": 2, 7 "user_name": "root", 8 "password": "" 9 } 10 } ``` commands for PROXY: ``` ./srpc proxy ``` will get the following instructions: ``` Missing: PROJECT_NAME Usage: ./srpc proxy <PROJECT_NAME> [FLAGS] Example: ./srpc redis myproxyproject Available Flags: -c : client type for proxy [ Http | Redis | SRPC | SRPCHttp | BRPC | Thrift | ThriftHttp | TRPC | TRPCHttp ] (default: Http) -s : server type for proxy [ Http | Redis | SRPC | SRPCHttp | BRPC | Thrift | ThriftHttp | TRPC | TRPCHttp ] (default: Http) -o : project output path (default: CURRENT_PATH) -d : path of dependencies (default: COMPILE_PATH) ``` Let's make a project with diffrent protocol: ``` ./srpc proxy srpctrpcproxy_example -c SRPC -s TRPC ``` ``` Success: make project path " ./srpctrpcproxy_example/ " done. Commands: cd ./srpctrpcproxy_example/ make -j Execute: ./server ./proxy ./client ``` Check the files in directory: ``` cd srpctrpcproxy_example && tree ``` ``` . CMakeLists.txt GNUmakefile client.conf client_main.cc config Json.cc Json.h config.cc config.h proxy.conf proxy_main.cc server.conf server_main.cc srpctrpcproxy_example.proto 2 directories, 13 files ``` Execute `./server` `./proxy` and `./client` on the three sessions respectively, and we will see that the client sends trpc protocol requests "Hello, this is sync request!" and "Hello, this is async request!" to the proxy, and the proxy receives the request and send to server as srpc protocol. SRPC server fill the response "Hi back" and will finnally transfer back to client by proxy. ``` ./server srpctrpcproxy_example TRPC server started, port 1412 get req: message: "Hello, this is sync request!" get req. message: "Hello, this is async request!" ``` ```

srpctrpcproxy_example [SRPC]-[TRPC] proxy start, port 1411 srpctrpcproxy_example proxy get request from client. ip : 127.0.0.1 message: "Hello, this is sync request!" srpctrpcproxy_example proxy get request from client. ip : 127.0.0.1 message: "Hello, this is async request!" ``` ``` ./client sync resp. message: "Hi back" async resp. message: "Hi back" ``` This is a simple file server. File reading is asynchronous, and the threads for process( ) will not be blocked by file IOs. ``` ./srpc file file_project ``` will get the following infomation: ``` Success: make project path " ./file_project/ " done. Commands: cd ./file_project/ make -j Execute: ./server Try file service: curl localhost:8080/index.html curl -i localhost:8080/a/b/ ``` Check the files in directories: ``` . CMakeLists.txt GNUmakefile config Json.cc Json.h config.cc config.h file_service.cc file_service.h html 404.html 50x.html index.html server.conf server_main.cc 3 directories, 13 files ``` Also check the `server.conf`, we can see the `root` and `error_page` are added into file service. We can specify the root to find files for this service, and fill the page coresponding to the error codes. ``` 1 { 2 "server": 3 { 4 "port": 8080, 5 "root": "./html/", 6 "error_page" : [ 7 { 8 "error" : [ 404 ], 9 "page" : "404.html" 10 }, 11 { 12 "error" : [ 500, 502, 503, 504], 13 "page" : "50x.html" 14 } 15 ] 16 } 17 } ``` After we execute `make` and run the server with `./server`, we can make requests with `curl`: example 1: read the file `index.html` in root path `./html/`. ``` curl localhost:8080/index.html <html>Hello from workflow and srpc file server!</html> ``` example 2: read the file `/a/b/`. This does't exist, so the error page `404.html` for `404` will be return as we fill them into `server.conf` above. ``` curl -i localhost:8080/a/b/ HTTP/1.1 404 Not Found Server: SRPC HTTP File Server Content-Length: 59 Connection: Keep-Alive <html>This is not the web page you are looking for.</html> ``` The log printed by server: ``` ./server http file service start, port 8080 file service get request: /a/b/ ``` Next is a simple calculation server, similarly, the calculation will not block the server processing thread. ``` ./srpc compute compute_test ``` Through the above command, we can create a project, which receives the url request as the parameter n, and performs Fibonacci calculation. ``` Success: make project path " compute_test/ " done. Commands: cd compute_test/ make -j Execute: ./server Try compute with n=8: curl localhost:8080/8 ``` Enter the `compute_test/` directory and use `make` to compile and execute `./server` to run. Then we can use curl or browser to enter `localhost:8080/8` to calculate the 8th Fibonacci number. Here take curl as an example: ``` curl localhost:8080/8 <html><p>0 + 1 = 1.</p><p>1 + 1 = 2.</p><p>1 + 2 = 3.</p><p>2 + 3 = 5.</p><p>3 + 5 = 8.</p><p>5 + 8 = 13.</p><p>The No. 8 Fibonacci number is: 13.</p></html> ``` We can see the calculation steps inside the server. This computing example of the server uses go_task to encapsulate a function. Welcome to try more computing scheduling.