uber / prototool

Your Swiss Army Knife for Protocol Buffers
MIT License
5.05k stars 345 forks source link
grpc grpc-go proto3 protobuf protoc protocol-buffers

Prototool

MIT License GitHub Release Build Status Coverage Status Docker Image Homebrew Package AUR Package

Update: We recommend checking out Buf, which is under active development. There are a ton of docs for getting started, including for migration from Prototool.

Protobuf is one of the best interface description languages out there - it's widely adopted, and after over 15 years of use, it's practically bulletproof. However, working with Protobuf and maintaining consistency across your Protobuf files can be a pain - protoc, while being a tool that has stood the test of time, is non-trivial to use, and the Protobuf community has not developed common standards with regards to stub generation. Prototool aims to solve this by making working with Protobuf much simpler.

Prototool lets you:

Prototool accomplishes this by downloading and calling protoc on the fly for you, handing error messages from protoc and your plugins, and using the generated FileDescriptorSets for internal functionality, as well as wrapping a few great external libraries already in the Protobuf ecosystem. Compiling, linting and formatting commands run in around 3/100ths of second for a single Protobuf file, or under a second for a larger number (500+) of Protobuf files.

Table Of Contents

Installation

Prototool can be installed on Mac OS X or Linux through a variety of methods.

See install.md for full instructions.

Quick Start

We'll start with a general overview of the commands. There are more commands, and we will get into] usage below, but this shows the basic functionality.

prototool help
prototool lint idl/uber # search for all .proto files recursively, obeying exclude_paths in prototool.yaml or prototool.json files
prototool lint # same as "prototool lint .", by default the current directory is used in directory mode
prototool create foo.proto # create the file foo.proto from a template that passes lint
prototool files idl/uber # list the files that will be used after applying exclude_paths from corresponding prototool.yaml or prototool.json files
prototool lint --list-linters # list all current lint rules being used
prototool lint --list-all-lint-groups # list all available lint groups, currently "google" and "uber"
prototool compile idl/uber # make sure all .proto files in idl/uber compile, but do not generate stubs
prototool generate idl/uber # generate stubs, see the generation directives in the config file example
prototool grpc idl/uber --address 0.0.0.0:8080 --method foo.ExcitedService/Exclamation --data '{"value":"hello"}' # call the foo.ExcitedService method Exclamation with the given data on 0.0.0.0:8080
prototool descriptor-set --include-imports idl/uber # generate a FileDescriptorSet for all files under idl/uber, outputting to stdout, a given file, or a temporary file
prototool break check idl/uber --git-branch master # check for breaking changes as compared to the Protobuf definitions in idl/uber on the master branch

Full Example

See the example directory.

The make command make example runs prototool while installing the necessary plugins.

Configuration

Prototool operates using a config file named either prototool.yaml or prototool.json. Only one of prototool.yaml or prototool.json can exist in a given directory. For non-trivial use, you should have a config file checked in to at least the root of your repository. It is important because the directory of an associated config file is passed to protoc as an include directory with -I, so this is the logical location your Protobuf file imports should start from.

Recommended base config file:

protoc:
  version: 3.11.0
lint:
  group: uber2

See protoc.md for how Prototool handles working with protoc.

The command prototool config init will generate a config file in the current directory with the currently recommended options set.

When specifying a directory or set of files for Prototool to operate on, Prototool will search for config files for each directory starting at the given path, and going up a directory until hitting root. If no config file is found, Prototool will use default values and operate as if there was a config file in the current directory, including the current directory with -I to protoc.

If multiple prototool.yaml or prototool.json files are found that match the input directory or files, an error will be returned.

See etc/config/example/prototool.yaml all available options.

File Discovery

In most Prototool commands, you will see help along the following lines:

$ prototool help lint
Lint proto files and compile with protoc to check for failures.

Usage:
  prototool lint [dirOrFile] [flags]

dirOrFile can take two forms:

The idea with "directory builds" is that you often need more than just one file to do a protoc call, for example if you have types in other files in the same package that are not referenced by their fully-qualified name, and/or if you need to know what directories to specify with -I to protoc (by default, the directory of the prototool.yaml or prototool.json file is used).

Command Overview

Let's go over some of the basic commands.

prototool config init

Create a prototool.yaml file in the current directory with the currently recommended options set.

Pass the --document flag to generate a prototool.yaml file with all other options documented and commented out.

Pass the --uncomment flag to generate prototool.yaml file with all options documented but uncommented.

See etc/config/example/prototool.yaml for the config file that prototool config init --uncomment generates.

prototool compile

Compile your Protobuf files, but do not generate stubs. This has the effect of calling protoc with -o /dev/null.

Pass the --dry-run flag to see the protoc commands that Prototool runs behind the scenes.

prototool generate

Compile your Protobuf files and generate stubs according to the rules in your prototool.yaml or prototool.json file.

See etc/config/example/prototool.yaml for all available options. There are special options available for Golang plugins, and plugins that output a single file instead of a set of files. Specifically, you can output a single JAR for the built-in protoc java plugin, and you can output a file with the serialized FileDescriptorSet using the built-in protoc descriptor_set plugin, optionally also calling --include_imports and/or --include_source_info.

Pass the --dry-run flag to see the protoc commands that Prototool runs behind the scenes.

See example/proto/prototool.yaml for a full example.

prototool lint

Lint rules can be set using the configuration file. See the configuration at etc/config/example/prototool.yaml for all available options. There are three pre-configured groups of rules, the setting of which is integral to the prototool lint, prototool create, and prototool format commands:

The flag --generate-ignores will help with migrating to a given lint group by generating the configuration to ignore existing lint failures on a per-file basis.

See lint.md for full instructions.

prototool format

Format a Protobuf file and print the formatted file to stdout. There are flags to perform different actions:

prototool create

Create Protobuf files from a template. With the provided Vim integration, this will automatically create new files that pass lint when a new file is opened.

See create.md for full instructions.

prototool files

Print the list of all files that will be used given the input dirOrFile. Useful for debugging.

prototool break check

Protobuf is a great way to represent your APIs and generate stubs in each language you develop with. As such, Protobuf APIs should be stable so as not to break consumers across repositories. Even in a monorepo context, making sure that your Protobuf APIs do not introduce breaking changes is important so that different deployed versions of your services do not have wire incompatibilities.

Prototool exposes a breaking change detector through the prototool break check command. This will check your current Protobuf definitions against a past version of your Protobuf definitions to see if there are any source or wire incompatible changes. Some notes on this command:

See breaking.md for full instructions.

prototool descriptor-set

Produce a serialized FileDescriptorSet for all Protobuf definitions. By default, the serialized FileDescriptorSet is printed to stdout. There are a few options:

The outputted FileDescriptorSet is a merge of all produced FileDescriptorSets for each Protobuf package compiled.

This command is useful in a few situations.

One such situation is with external gRPC tools such as grpcurl or ghz. Both tools take a path to a serialized FileDescriptorSet for use to figure out the request/response structure of RPCs when the gRPC reflection service is not available. prototool descriptor-set can be used to generate these FileDescriptorSets on the fly.

grpcurl -protoset $(prototool descriptor-set --include-imports --tmp) ...
ghz -protoset $(prototool descriptor-set --include-imports --tmp) ...

You can also just save the file once and not re-compile each time.

prototool descriptor-set --include-imports -o descriptor_set.bin
grpcurl -protoset descriptor_set.bin ...
ghz -protoset descriptor_set.bin ...

Another situation is to use jq to make arbitrary queries on your Protobuf definitions.

For example, if your Protobuf definitions are in path/to/proto, the following will print all message names.

prototool descriptor-set path/to/proto --json | \
  jq '.file[] | select(.messageType != null) | .messageType[] | .name' | \
  sort | uniq
prototool grpc

Call a gRPC endpoint using a JSON input. What this does behind the scenes:

See grpc.md for full instructions.

Tips and Tricks

Prototool is meant to help enforce a consistent development style for Protobuf, and as such you should follow some basic rules:

Vim Integration

This repository is a self-contained plugin for use with the ALE Lint Engine. The Vim integration will currently compile, provide lint errors, do generation of your stubs, and format your files on save. It will also optionally create new files from a template when opened.

See vim.md for full instructions.

Stability

Prototool is generally available, and conforms to SemVer, so Prototool will not have any breaking changes on a given major version, with some exceptions:

Development

See development.md for concerns related to Prototool development.

See maintenance.md for maintenance-related tasks.

FAQ

See faq.md for answers to frequently asked questions.

Special Thanks

Prototool uses some external libraries that deserve special mention and thanks for their contribution to Prototool's functionality: