package main import ( "flag" "fmt" "os" "strings" "github.com/golang/glog" "github.com/golang/protobuf/proto" plugin "github.com/golang/protobuf/protoc-gen-go/plugin" "github.com/grpc-ecosystem/grpc-gateway/codegenerator" "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway/descriptor" "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/genswagger" ) var ( importPrefix = flag.String("import_prefix", "", "prefix to be added to go package paths for imported proto files") file = flag.String("file", "-", "where to load data from") allowDeleteBody = flag.Bool("allow_delete_body", false, "unless set, HTTP DELETE methods may not have a body") grpcAPIConfiguration = flag.String("grpc_api_configuration", "", "path to gRPC API Configuration in YAML format") allowMerge = flag.Bool("allow_merge", false, "if set, generation one swagger file out of multiple protos") mergeFileName = flag.String("merge_file_name", "apidocs", "target swagger file name prefix after merge") useJSONNamesForFields = flag.Bool("json_names_for_fields", false, "if it sets Field.GetJsonName() will be used for generating swagger definitions, otherwise Field.GetName() will be used") repeatedPathParamSeparator = flag.String("repeated_path_param_separator", "csv", "configures how repeated fields should be split. Allowed values are `csv`, `pipes`, `ssv` and `tsv`.") versionFlag = flag.Bool("version", false, "print the current version") allowRepeatedFieldsInBody = flag.Bool("allow_repeated_fields_in_body", false, "allows to use repeated field in `body` and `response_body` field of `google.api.http` annotation option") includePackageInTags = flag.Bool("include_package_in_tags", false, "if unset, the gRPC service name is added to the `Tags` field of each operation. if set and the `package` directive is shown in the proto file, the package name will be prepended to the service name") useFQNForSwaggerName = flag.Bool("fqn_for_swagger_name", false, "if set, the object's swagger names will use the fully qualify name from the proto definition (ie my.package.MyMessage.MyInnerMessage") useGoTemplate = flag.Bool("use_go_templates", false, "if set, you can use Go templates in protofile comments") disableDefaultErrors = flag.Bool("disable_default_errors", false, "if set, disables generation of default errors. This is useful if you have defined custom error handling") enumsAsInts = flag.Bool("enums_as_ints", false, "whether to render enum values as integers, as opposed to string values") simpleOperationIDs = flag.Bool("simple_operation_ids", false, "whether to remove the service prefix in the operationID generation. Can introduce duplicate operationIDs, use with caution.") ) // Variables set by goreleaser at build time var ( version = "dev" commit = "unknown" date = "unknown" ) func main() { flag.Parse() defer glog.Flush() if *versionFlag { fmt.Printf("Version %v, commit %v, built at %v\n", version, commit, date) os.Exit(0) } reg := descriptor.NewRegistry() glog.V(1).Info("Processing code generator request") f := os.Stdin if *file != "-" { var err error f, err = os.Open(*file) if err != nil { glog.Fatal(err) } } glog.V(1).Info("Parsing code generator request") req, err := codegenerator.ParseRequest(f) if err != nil { glog.Fatal(err) } glog.V(1).Info("Parsed code generator request") pkgMap := make(map[string]string) if req.Parameter != nil { err := parseReqParam(req.GetParameter(), flag.CommandLine, pkgMap) if err != nil { glog.Fatalf("Error parsing flags: %v", err) } } reg.SetPrefix(*importPrefix) reg.SetAllowDeleteBody(*allowDeleteBody) reg.SetAllowMerge(*allowMerge) reg.SetMergeFileName(*mergeFileName) reg.SetUseJSONNamesForFields(*useJSONNamesForFields) reg.SetAllowRepeatedFieldsInBody(*allowRepeatedFieldsInBody) reg.SetIncludePackageInTags(*includePackageInTags) reg.SetUseFQNForSwaggerName(*useFQNForSwaggerName) reg.SetUseGoTemplate(*useGoTemplate) reg.SetEnumsAsInts(*enumsAsInts) reg.SetDisableDefaultErrors(*disableDefaultErrors) reg.SetSimpleOperationIDs(*simpleOperationIDs) if err := reg.SetRepeatedPathParamSeparator(*repeatedPathParamSeparator); err != nil { emitError(err) return } for k, v := range pkgMap { reg.AddPkgMap(k, v) } if *grpcAPIConfiguration != "" { if err := reg.LoadGrpcAPIServiceFromYAML(*grpcAPIConfiguration); err != nil { emitError(err) return } } g := genswagger.New(reg) if err := genswagger.AddStreamError(reg); err != nil { emitError(err) return } if err := reg.Load(req); err != nil { emitError(err) return } var targets []*descriptor.File for _, target := range req.FileToGenerate { f, err := reg.LookupFile(target) if err != nil { glog.Fatal(err) } targets = append(targets, f) } out, err := g.Generate(targets) glog.V(1).Info("Processed code generator request") if err != nil { emitError(err) return } emitFiles(out) } func emitFiles(out []*plugin.CodeGeneratorResponse_File) { emitResp(&plugin.CodeGeneratorResponse{File: out}) } func emitError(err error) { emitResp(&plugin.CodeGeneratorResponse{Error: proto.String(err.Error())}) } func emitResp(resp *plugin.CodeGeneratorResponse) { buf, err := proto.Marshal(resp) if err != nil { glog.Fatal(err) } if _, err := os.Stdout.Write(buf); err != nil { glog.Fatal(err) } } // parseReqParam parses a CodeGeneratorRequest parameter and adds the // extracted values to the given FlagSet and pkgMap. Returns a non-nil // error if setting a flag failed. func parseReqParam(param string, f *flag.FlagSet, pkgMap map[string]string) error { if param == "" { return nil } for _, p := range strings.Split(param, ",") { spec := strings.SplitN(p, "=", 2) if len(spec) == 1 { if spec[0] == "allow_delete_body" { err := f.Set(spec[0], "true") if err != nil { return fmt.Errorf("Cannot set flag %s: %v", p, err) } continue } if spec[0] == "allow_merge" { err := f.Set(spec[0], "true") if err != nil { return fmt.Errorf("Cannot set flag %s: %v", p, err) } continue } if spec[0] == "allow_repeated_fields_in_body" { err := f.Set(spec[0], "true") if err != nil { return fmt.Errorf("Cannot set flag %s: %v", p, err) } continue } if spec[0] == "include_package_in_tags" { err := f.Set(spec[0], "true") if err != nil { return fmt.Errorf("Cannot set flag %s: %v", p, err) } continue } err := f.Set(spec[0], "") if err != nil { return fmt.Errorf("Cannot set flag %s: %v", p, err) } continue } name, value := spec[0], spec[1] if strings.HasPrefix(name, "M") { pkgMap[name[1:]] = value continue } if err := f.Set(name, value); err != nil { return fmt.Errorf("Cannot set flag %s: %v", p, err) } } return nil }