Shulou(Shulou.com)06/03 Report--

This article shares with you the content of the sample analysis of DotBPE.RPC. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Introduction to 0x00

DotBPE.RPC is a RPC framework based on dotnet core, and its father, DotBPE, aims to achieve a micro-service framework that is ready to use out of the box, but it almost means that it is only in the stage of conception and trial. But anyway, RPC is the foundation of microservices, so let's talk about the implementation of RPC first. The DotBPE.RPC underlying communication implementation is based on DotNetty by default, which is the Netty implementation of C# developed by Microsoft Azure team, which is very cool. Of course, you can also replace it with other Socket communication components. The default protocol name used by DotBPE.RPC is Amp, and Google's Protobuf3 is used for encoding and decoding, but these default implementations are replaceable.

Undefined

0x01 on Amp Protocol and Google ProtobufAmp (A Message Protocol)

Amp (A Message Protocol), known as a message protocol in Chinese, is the default message protocol implemented by DotBPE.RPC. In actual development, there is no need to understand how messages are encoded, decoded and transmitted, but understanding the protocol helps to further understand the framework. The basic structure of the protocol is shown in the following figure:

0 12 3 4 5 6 7 8 9 10 11 12 13-14 color color + | +-+ -+

The default header of Amp protocol is 14 bytes long and does not contain extension packet headers.

Bit 0: ver/argc / / is the version number. For the time being, the default is 0.

Bit 1-4: length / / is the total packet length (including header length)

Bit 5-8: sequence / / is the message sequence number, which is used to respond to the request.

No. 9: type / / message type. There are 5 types of current values, as follows:

Request = 1, Response = 2, Notify = 3 NotFound = 4, ERROR = 5

Bit 10-11: serviceId// message ID ushort type

Bit 12-13: msgId// message ID ushort type

In the Amp protocol, serviceId identifies a kind of request, similar to a module in an application, while msgId identifies a specific method in the module.

Followed by the actual data.

Google Protobuf

Google Protocol Buffer (Protobuf for short) is a mixed language data standard within Google, which has more than 48162 message format definitions and more than 12183 .proto files. They are used in RPC systems and continuous data storage systems.

Protocol Buffers is a lightweight and efficient structured data storage format that can be used for structured data serialization, or serialization. It is very suitable for data storage or RPC data exchange format. Can be used in communication protocols, data storage and other fields of language-independent, platform-independent, extensible serialized structural data format. API is available in many languages, including C++, C#, GO, JAVA, PYTHON

In my previous blog writing Google Protobuf plug-ins using CSharp, I introduced how to write plug-ins by defining proto files and generating the code we need.

In DotBPE.RPC, I use protobuf as the description file for the service and generate server-side and client-side proxy classes through custom plug-ins.

0x02 quickly starts 0. 0. Premise

Because DotBPE is based on dotnet core, you must already have a dotnet core development environment locally

Use github managed code, so you must already have a git client installed

Template code needs to be generated through protoc, so you must have installed the google protobuf command line tool

1. Download the sample program

In order to explain our quick start program, you need a sample code that can be run locally. Download the sample code I have written from github, which allows you to build the program quickly, eliminating some tedious but necessary steps.

> $# Clone the repository to get the example code: > $git clone https://github.com/xuanye/dotbpe-sample.git > $cd dotbpe-sample

Use VS2017, or VSCode to open the downloaded code, and the directory structure is as follows:

If you use VS2017, you can automatically restore it. If you use VSCode, you need to run dotnet restore download dependency. After success, use dotnet build to compile and see the result: it looks perfect.

two。 Run the program run Server > $cd HelloDotBPE.Server > $dotnet run run Client > $cd HelloDotBPE.Client > $dotnet run

Congratulations! An application for Server/Client has been run using DotBPE.RPC.

3. Let's take a look at the code. 3. 1 Service description file proto

First of all, there is the extension file for proto in the DotBPE.RPC framework, which is needed for all projects. My blog has a more detailed introduction on how to extend proto, so I won't repeat it here.

/ / dotbpe_option.proto file syntax = "proto3"; package dotbpe;option csharp_namespace = "DotBPE.ProtoBuf"; import "google/protobuf/descriptor.proto"; / / extended service extend google.protobuf.ServiceOptions {int32 service_id = 51001; bool disable_generic_service_client = 51003; / / prohibit the generation of client code bool disable_generic_service_server = 51004; / / prohibit the generation of server code} extend google.protobuf.MethodOptions {int32 message_id = 51002 } extend google.protobuf.FileOptions {bool disable_generic_services_client = 51003; / / prohibit the generation of client code bool disable_generic_services_server = 51004; / / prohibit the generation of server code bool generic_markdown_doc = 51005; / / whether to generate documentation in this case useless bool generic_objectfactory = 51006; / / whether to generate objectfactory useless in this example}

The following service description file greeter.proto is the real example service description file: it is relatively simple to define a Greeter Rpc service and define a Hello method

/ / greeter.protosyntax = "proto3"; package dotbpe;option csharp_namespace = "HelloDotBPE.Common"; / / introduce extended import public "dotbpe_option.proto"; / / define a service service Greeter {option (service_id) = 100; / / message ID, global must be unique / / Sends a greeting rpc Hello (HelloRequest) returns (HelloResponse) {option (message_id) = 1 / / set message ID, unique within the same service}} / / The request message containing the user's name.message HelloRequest {string name = 1;} / / The response message containing the greetingsmessage HelloResponse {string message = 1;}

The template code is generated by the protoc tool, and the code in the example is generated into the HelloDotBPE.Common_g directory. Students who can run the shell command locally can go directly to the

The dotbpe-sample\ script\ generate directory runs sh generate_hello.sh (cgywin is generally installed under windows). Students who can't run it can also run the command line directly under the HelloDotBPE directory.

Protoc- I=../protos-- csharp_out=./HelloDotBPE.Common/_g/-- dotbpe_out=./HelloDotBPE.Common/_g/. / protos/dotbpe_option.proto.. / protos/greeter.proto-- plugin=protoc-gen-dotbpe=../../tool/protoc_plugin/Protobuf.Gen.exe

Of course, I still recommend that you install the following cgywin runtime environment, and you can run some common commands on unix. At the same time, some scripts of the development environment can be shared when deploying to the formal environment.

3.2 Server code

Service implementation:

/ / Service implementation code public class GreeterImpl: GreeterBase {public override Task HelloAsync (HelloRequest request) {/ / return Hello Name return Task.FromResult directly (new HelloResponse () {Message = "Hello" + request.Name});}}

Server startup class

Public class Startup: IStartup {public void Configure (IAppBuilder app, IHostingEnvironment env) {} public IServiceProvider ConfigureServices (IServiceCollection services) {services.AddDotBPE (); / / add DotBPE.RPC 's core dependency services.AddServiceActors (actors = > {actors.Add (); / / register service implementation}) Return services.BuildServiceProvider ();}}

Start the server

Class Program {static void Main (string [] args) {Console.OutputEncoding = System.Text.Encoding.UTF8; / / output debug log DotBPE.Rpc.Environment.SetLogger (new DotBPE.Rpc.Logging.ConsoleLogger ()) in the console Var host = new RpcHostBuilder () .UseServer ("0.0.0.0 Console.WriteLine 6201") / / bind local port 6201 .UseStartup () .build (); host.StartAsync () .UseServer (); Console.WriteLine ("Press any key to quit!"); Console.ReadKey () Host.ShutdownAsync () .Wait ();} 3.3 client code class Program {static void Main (string [] args) {Console.OutputEncoding = Encoding.UTF8; var client = AmpClient.Create ("127.0.0.1 class Program 6201"); / / establish a link channel var greeter = new GreeterClient (client) / / client agent class while (true) {Console.WriteLine ("input your name and press enter:"); string name = Console.ReadLine (); if ("bye" .equals (name)) {break } try {var request = new HelloRequest () {Name = name}; var result = greeter.HelloAsync (request) .Result Console.WriteLine ($"- receive form server: {result.Message} -") } catch (Exception ex) {Console.WriteLine ("error occurs:" + ex.Message) }} Console.WriteLine ($"- close connection-"); client.CloseAsync ();}} Thank you for reading! This is the end of this article on "sample Analysis of DotBPE.RPC". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.