Base grpc generation

Author: ebroberson

protoc-gen-go-bbs/bbs.go

@@ -6,6 +6,7 @@ import (
 	"slices"
 	"strings"
 	"text/template"
+	"unicode"
 
 	"google.golang.org/protobuf/compiler/protogen"
 	"google.golang.org/protobuf/proto"
@@ -27,17 +28,31 @@ type bbsGenerateHelperInterface interface {
 }
 type bbsGenerateHelper struct{}
 
+var ignoredMessages []string = []string{"ProtoRoutes"}
+var ignoredEnums []string = []string{}
+var ignoredServices []string = []string{}
+
 var helper bbsGenerateHelperInterface = bbsGenerateHelper{}
 
 func getUnsafeName(g *protogen.GeneratedFile, ident protogen.GoIdent) string {
 	return g.QualifiedGoIdent(ident)
 }
 
+func getUnsafeNameFromString(name protoreflect.Name) string {
+	unsafeName := name
+	return string(unsafeName)
+}
+
 func getCopysafeName(g *protogen.GeneratedFile, ident protogen.GoIdent) (string, bool) {
 	unsafeName := getUnsafeName(g, ident)
 	return strings.CutPrefix(unsafeName, *prefix)
 }
 
+func getCopysafeNameFromString(name protoreflect.Name) (string, bool) {
+	unsafeName := getUnsafeNameFromString(name)
+	return strings.CutPrefix(unsafeName, *prefix)
+}
+
 func getFieldName(goName string) string {
 	result := goName
 	return result
@@ -694,6 +709,27 @@ func generateFile(plugin *protogen.Plugin, file *protogen.File) *protogen.Genera
 	return g
 }
 
+func generateRpcFile(plugin *protogen.Plugin, file *protogen.File) *protogen.GeneratedFile {
+	filename := file.GeneratedFilenamePrefix + "_bbs_grpc.pb.go"
+	g := plugin.NewGeneratedFile(filename, file.GoImportPath)
+	g.P("// Code generated by protoc-gen-go-bbs. DO NOT EDIT.")
+	g.P("// versions:")
+	g.P("// - protoc-gen-go-bbs v", version) // version from main.go
+	g.P("// - protoc-gen-go-grpc ", "TODO: get version")
+	g.P("// - protoc            ", protocVersion(plugin))
+
+	if file.Proto.GetOptions().GetDeprecated() {
+		g.P("// ", file.Desc.Path(), " is a deprecated file.")
+	} else {
+		g.P("// source: ", file.Desc.Path())
+	}
+	g.P()
+	g.P("package ", file.GoPackageName)
+	g.P()
+	generateRpcFileContent(file, g)
+	return g
+}
+
 func protocVersion(plugin *protogen.Plugin) string {
 	v := plugin.Request.GetCompilerVersion()
 	if v == nil {
@@ -706,10 +742,7 @@ func protocVersion(plugin *protogen.Plugin) string {
 	return fmt.Sprintf("v%d.%d.%d%s", v.GetMajor(), v.GetMinor(), v.GetPatch(), suffix)
 }
 
-var ignoredMessages []string = []string{"ProtoRoutes"}
-var ignoredEnums []string = []string{}
-
-func generateFileContent(file *protogen.File, g *protogen.GeneratedFile) {
+func generateFileEnums(file *protogen.File, g *protogen.GeneratedFile) {
 	for _, eNuM := range file.Enums {
 		if *debug {
 			log.Printf("New Enum Detected: %+v\n\n", eNuM)
@@ -722,7 +755,9 @@ func generateFileContent(file *protogen.File, g *protogen.GeneratedFile) {
 
 		helper.genGlobalEnum(g, eNuM)
 	}
+}
 
+func generateFileMessages(file *protogen.File, g *protogen.GeneratedFile) {
 	for _, msg := range file.Messages {
 		if *debug {
 			log.Printf("New Message Detected: %+v\n\n", msg)
@@ -740,3 +775,176 @@ func generateFileContent(file *protogen.File, g *protogen.GeneratedFile) {
 		helper.genFromProtoSliceMethod(g, msg)
 	}
 }
+
+var currentService Service
+
+func generateFileServices(file *protogen.File, g *protogen.GeneratedFile) {
+	for _, svc := range file.Services {
+		if *debug {
+			log.Printf("New Service Detected: %+v\n\n", svc)
+		}
+
+		if slices.Contains(ignoredServices, svc.GoName) {
+			log.Printf("\tIgnoring service %s", svc.Desc.Name())
+			continue
+		}
+
+		if serviceName, ok := getCopysafeNameFromString(svc.Desc.Name()); ok {
+			sourceFilename := file.Desc.Path()
+			currentService = Service{Name: serviceName, Source: sourceFilename}
+
+			genImports(g)
+			genClient(g, svc)
+			genServer(g, svc)
+			genServiceDesc(g, svc)
+		}
+	}
+}
+
+var funcMap template.FuncMap = template.FuncMap{
+	"LowerFirst": lowerFirst,
+}
+
+func lowerFirst(s string) string {
+	if len(s) == 0 {
+		return s
+	}
+
+	runes := []rune(s)
+	runes[0] = unicode.ToLower(runes[0])
+	return string(runes)
+}
+
+func genImports(g *protogen.GeneratedFile) {
+	importBuilder := new(strings.Builder)
+	importT, err := template.New("import").Funcs(funcMap).Parse(grpcImports)
+	if err != nil {
+		panic(err)
+	}
+	importT.Execute(importBuilder, nil)
+	g.P(importBuilder.String())
+
+}
+
+func genClient(g *protogen.GeneratedFile, svc *protogen.Service) {
+	clientMethodNames := genMethodTemplate(svc, clientMethodName, false)
+	clientInterfaceMethods := genMethodTemplate(svc, clientInterfaceMethod, false)
+	clientMethods := genMethodTemplate(svc, clientMethod, false)
+	clientBuilder := new(strings.Builder)
+
+	clientT, err := template.New("client").Funcs(funcMap).Parse(grpcClient)
+	if err != nil {
+		panic(err)
+	}
+	clientT.Execute(clientBuilder,
+		Client{
+			Service:                currentService,
+			ClientInterfaceMethods: clientInterfaceMethods,
+			ClientMethodNames:      clientMethodNames,
+			ClientMethods:          clientMethods,
+		})
+	g.P(clientBuilder.String())
+}
+
+func genServer(g *protogen.GeneratedFile, svc *protogen.Service) {
+	unimplementedServerMethods := genMethodTemplate(svc, unimplementedServerMethod, false)
+	serverInterfaceMethods := genMethodTemplate(svc, serverInterfaceMethod, false)
+	serverHandlers := genMethodTemplate(svc, serverHandler, false)
+
+	serverBuilder := new(strings.Builder)
+	serverT, err := template.New("server").Funcs(funcMap).Parse(grpcServer)
+	if err != nil {
+		panic(err)
+	}
+
+	serverT.Execute(serverBuilder,
+		Server{
+			Service:                    currentService,
+			ServerHandlers:             serverHandlers,
+			ServerInterfaceMethods:     serverInterfaceMethods,
+			UnimplementedServerMethods: unimplementedServerMethods,
+		})
+	g.P(serverBuilder.String())
+}
+
+func genMethodTemplate(svc *protogen.Service, methodTemplate string, addComma bool) string {
+	builder := new(strings.Builder)
+	methodT, err := template.New("method-template").Funcs(funcMap).Parse(methodTemplate)
+	if err != nil {
+		panic(err)
+	}
+
+	for i, method := range svc.Methods {
+		methodName, _ := getCopysafeNameFromString(method.Desc.Name())
+		methodT.Execute(builder,
+			Method{
+				Service:    currentService,
+				MethodName: methodName,
+			})
+		if addComma {
+			if i < len(svc.Methods)-1 {
+				builder.WriteRune(',')
+			}
+		}
+	}
+	return builder.String()
+}
+
+type Service struct {
+	Name   string
+	Source string
+}
+
+type Client struct {
+	ClientInterfaceMethods string
+	ClientMethodNames      string
+	ClientMethods          string
+	Service                Service
+}
+
+type Server struct {
+	ServerInterfaceMethods     string
+	ServerHandlers             string
+	Service                    Service
+	UnimplementedServerMethods string
+}
+
+type ServiceDescData struct {
+	Methods string
+	Service Service
+}
+
+type Method struct {
+	MethodName string
+	Service    Service
+}
+
+func genServiceDesc(g *protogen.GeneratedFile, svc *protogen.Service) {
+	methodsBuilder := new(strings.Builder)
+	methodsBuilder.WriteString("Methods: []grpc.MethodDesc{")
+	serviceDescMethods := genMethodTemplate(svc, grpcMethodDesc, true)
+	methodsBuilder.WriteString(serviceDescMethods)
+	methodsBuilder.WriteString("}")
+	methods := methodsBuilder.String()
+
+	serviceDescBuilder := new(strings.Builder)
+	serviceDescT, err := template.New("serviceDesc").Parse(grpcServiceDescription)
+	if err != nil {
+		panic(err)
+	}
+	serviceDescT.Execute(serviceDescBuilder,
+		ServiceDescData{
+			Service: currentService,
+			Methods: methods,
+		})
+	g.P(serviceDescBuilder.String())
+}
+
+func generateFileContent(file *protogen.File, g *protogen.GeneratedFile) {
+	generateFileEnums(file, g)
+	generateFileMessages(file, g)
+}
+
+func generateRpcFileContent(file *protogen.File, g *protogen.GeneratedFile) {
+	generateFileServices(file, g)
+}

protoc-gen-go-bbs/main.go

@@ -42,6 +42,10 @@ func main() {
 			log.Printf("Generating %s\n", file.Desc.Path())
 
 			generateFile(plugin, file)
+			if len(file.Services) > 0 {
+				generateRpcFile(plugin, file)
+			}
+
 		}
 		return nil
 	})