Created a debuggable gRPC GUI client

[[437208]]

This article is reprinted from the WeChat public account "crossoverJie", the author is crossoverJie. Please contact the crossoverJie public account to reprint this article.

Preface

How do you usually test the gRPC interface after writing it? There are usually the following methods:

Write unit test code and simulate client testing yourself.

You can set up a gRPC-Gateway service so that you can simulate it in postman.

But neither of these two methods is particularly elegant; the first method is not very intuitive to maintain in the code when the nested request structure is particularly complex; and the code will be particularly long.

The second method looks very intuitive in Postman, just like requesting the HTTP interface. However, it requires maintaining a gRPC-Gateway service and republishing it when the interface definition changes, which makes it a little more complicated to use.

So after some searching I found two tools that looked good:

• BloomRPC
• https://github.com/fullstorydev/grpcui

First of all, the BloomRPC page is beautiful and its functions are complete; but there is one very uncomfortable thing, that is, it does not support int64 data requests, which will cause precision problems.

Here I wrote a simple interface that directly returns the requested int64.

 func (o * Order ) Create (ctx context.Context, in *v1.OrderApiCreate) (*v1. Order , error) {
 fmt.Println( in .OrderId)
 return & v1.Order {
 OrderId: in .OrderId,
 Reason: nil,
 }, nil
 }

You will find that the accuracy of the data received by the server has been lost.

This is very troublesome in our business that uses a lot of int64, and most of the interfaces cannot be used.

grpcui is a tool I discovered after using BloomRPC for a while. It has relatively complete functions and the accuracy problem in BloomRPC does not exist.

But since I was used to debugging interfaces in BloomRPC, and my browser usually has dozens of tap pages open during daily development, it was not so convenient to find grpcui among them.

So I wondered if there could be an independent APP similar to BloomRPC that also supports int64 tools.

Prepare

After searching for a while, I didn't seem to find it. It happened that I wrote a gRPC stress testing tool some time ago, which actually implemented the core function required by the APP, that is, generalized call.

Since the core capabilities are implemented in Go, it is best to write this app in Go as well, so that code reuse will be more convenient; I also want to see how well Go can be used to implement GUI applications.

Unfortunately, Go does not provide native GUI library support. Finally, I found a library: fyne

From the star, it seems to be used more frequently and also supports cross-platform packaging; so we finally decided to use this library to build this application.

Core Features

I referred to BloomRPC for the entire App's interaction process, but as a back-end developer who doesn't understand aesthetics and design, the most difficult part of the whole process is the layout.

This is the first version of the page that I spent several nights debugging. Although it works, it is very inconvenient to view the request and response data.

So I spent another weekend and the final version is as follows (at first glance, it seems no different):

Although there is still a certain gap between the page and BloomRPC, it does not affect the use; the key is that the int64 problem has been solved; you can happily code again.

Install

Friends who have similar needs and want to experience it can download it here: https://github.com/crossoverJie/ptg/releases/download/0.0.2/ptg-mac-gui.tar

Since I don't have a Windows computer at hand, I didn't package the exe program; friends who have related needs can download the source code and compile it by themselves:

 git clone [email protected]:crossoverJie/ptg.git
 cd ptg
 make pkg-win

Next steps

The current version is relatively simple and only supports commonly used unary calls. Support for stream, metadata, and workspace storage and restoration will be added in the future.

Suggestions on pages and interactions are also welcome.

I was originally going to upload it to brew for easy installation, but after a night of struggling, it was rejected because of insufficient data. So if it helps or is of interest to you, please pay attention (why does it feel like live streaming sales??)

Source code address: https://github.com/crossoverJie/ptg