go-common/app/tool/bmproto/protoc-gen-bm/generator.go

// Copyright 2018 Twitch Interactive, Inc.  All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"). You may not
// use this file except in compliance with the License. A copy of the License is
// located at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// or in the "license" file accompanying this file. This file is distributed on
// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.

package main

import (
	"bufio"
	"bytes"
	"compress/gzip"
	"fmt"
	"go/ast"
	"go/parser"
	"go/printer"
	"go/token"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"unicode"

	"go-common/app/tool/liverpc/protoc-gen-liverpc/gen"
	"go-common/app/tool/liverpc/protoc-gen-liverpc/gen/stringutils"
	"go-common/app/tool/liverpc/protoc-gen-liverpc/gen/typemap"

	"github.com/golang/protobuf/proto"
	"github.com/golang/protobuf/protoc-gen-go/descriptor"
	plugin "github.com/golang/protobuf/protoc-gen-go/plugin"
	"github.com/pkg/errors"
	"github.com/siddontang/go/ioutil2"
)

var legacyPathMapping = map[string]string{
	"live.webucenter":       "live.web-ucenter",
	"live.webroom":          "live.web-room",
	"live.appucenter":       "live.app-ucenter",
	"live.appblink":         "live.app-blink",
	"live.approom":          "live.app-room",
	"live.appinterface":     "live.app-interface",
	"live.liveadmin":        "live.live-admin",
	"live.resource":         "live.resource",
	"live.livedemo":         "live.live-demo",
	"live.lotteryinterface": "live.lottery-interface",
}

type bm struct {
	filesHandled int

	reg *typemap.Registry

	// Map to record whether we've built each package
	pkgs          map[string]string
	pkgNamesInUse map[string]bool

	importPrefix string            // String to prefix to imported package file names.
	importMap    map[string]string // Mapping from .proto file name to import path.
	tpl          bool              // only generate service template file, no docs, no .bm.go, default false

	// Package naming:
	genPkgName          string // Name of the package that we're generating
	fileToGoPackageName map[*descriptor.FileDescriptorProto]string

	// List of files that were inputs to the generator. We need to hold this in
	// the struct so we can write a header for the file that lists its inputs.
	genFiles []*descriptor.FileDescriptorProto

	// Output buffer that holds the bytes we want to write out for a single file.
	// Gets reset after working on a file.
	output *bytes.Buffer

	deps map[string]string
}

// if current dir is a go-common project
// or is the internal directory of a go-common project
// this present a project info
type projectInfo struct {
	absolutePath string
	// relative to go-common
	importPath string
	name       string
	department string
	// interface, service, admin ...
	typ            string
	hasInternalPkg bool
	// 从工作目录到project目录的相对路径 比如./ ../
	pathRefToProj string
}

// projectInfo for current directory
var projInfo *projectInfo

func bmGenerator() *bm {
	t := &bm{
		pkgs:                make(map[string]string),
		pkgNamesInUse:       make(map[string]bool),
		importMap:           make(map[string]string),
		fileToGoPackageName: make(map[*descriptor.FileDescriptorProto]string),
		output:              bytes.NewBuffer(nil),
	}

	return t
}

func (t *bm) Generate(in *plugin.CodeGeneratorRequest) *plugin.CodeGeneratorResponse {
	params, err := parseCommandLineParams(in.GetParameter())
	if err != nil {
		gen.Fail("could not parse parameters passed to --bm_out", err.Error())
	}
	t.importPrefix = params.importPrefix
	t.importMap = params.importMap
	t.tpl = params.tpl

	t.genFiles = gen.FilesToGenerate(in)

	// Collect information on types.
	t.reg = typemap.New(in.ProtoFile)

	t.registerPackageName("context")
	t.registerPackageName("ioutil")
	t.registerPackageName("proto")

	// Time to figure out package names of objects defined in protobuf. First,
	// we'll figure out the name for the package we're generating.
	genPkgName, err := deduceGenPkgName(t.genFiles)
	if err != nil {
		gen.Fail(err.Error())
	}
	t.genPkgName = genPkgName

	// Next, we need to pick names for all the files that are dependencies.
	if len(in.ProtoFile) > 0 {
		t.initProjInfo(in.ProtoFile[0])
	}
	for _, f := range in.ProtoFile {
		if fileDescSliceContains(t.genFiles, f) {
			// This is a file we are generating. It gets the shared package name.
			t.fileToGoPackageName[f] = t.genPkgName
		} else {
			// This is a dependency. Use its package name.
			name := f.GetPackage()
			if name == "" {
				name = stringutils.BaseName(f.GetName())
			}
			name = stringutils.CleanIdentifier(name)
			alias := t.registerPackageName(name)
			t.fileToGoPackageName[f] = alias
		}
	}

	// Showtime! Generate the response.
	resp := new(plugin.CodeGeneratorResponse)
	for _, f := range t.genFiles {
		respFile := t.generate(f)
		if respFile != nil {
			resp.File = append(resp.File, respFile)
		}
		for _, s := range f.Service {
			docResp := t.generateDoc(f, s)
			if docResp != nil {
				resp.File = append(resp.File, docResp)
			}
		}

		if t.tpl {
			if projInfo != nil {
				for _, s := range f.Service {
					serviceResp := t.generateServiceImpl(f, s)
					if serviceResp != nil {
						resp.File = append(resp.File, serviceResp)
					}
				}
			}
		}
	}
	return resp
}

// lookupProjPath get project path by proto absolute path
// assume that proto is in the project's model directory
func lookupProjPath(protoAbs string) (result string) {
	lastIndex := len(protoAbs)
	curPath := protoAbs

	for lastIndex > 0 {
		if ioutil2.FileExists(curPath+"/cmd") && ioutil2.FileExists(curPath+"/api") {
			result = curPath
			return
		}
		lastIndex = strings.LastIndex(curPath, string(os.PathSeparator))
		curPath = protoAbs[:lastIndex]
	}
	result = ""
	return
}

func (t *bm) initProjInfo(file *descriptor.FileDescriptorProto) {
	var err error
	projInfo = &projectInfo{}
	defer func() {
		if err != nil {
			projInfo = nil
		}
	}()
	wd, err := os.Getwd()
	if err != nil {
		panic("cannot get working directory")
	}
	protoAbs := wd + "/" + file.GetName()
	appIndex := strings.Index(wd, "go-common/app/")
	if appIndex == -1 {
		err = errors.New("not in go-common/app/")
		return
	}

	projPath := lookupProjPath(protoAbs)
	if projPath == "" {
		err = errors.New("not in project")
		return
	}
	if strings.Contains(wd, projPath) {
		rest := strings.Replace(wd, projPath, "", 1)
		projInfo.pathRefToProj = "./"
		if rest != "" {
			split := strings.Split(rest, "/")
			ref := ""
			for i := 0; i < len(split)-1; i++ {
				ref = ref + "../"
			}
			projInfo.pathRefToProj = ref
		}
	}
	projInfo.absolutePath = projPath
	if ioutil2.FileExists(projPath + "/internal") {
		projInfo.hasInternalPkg = true
	}

	relativePath := projInfo.absolutePath[appIndex+len("go-common/app/"):]
	projInfo.importPath = "go-common/app/" + relativePath
	split := strings.Split(relativePath, "/")
	projInfo.typ = split[0]
	projInfo.department = split[1]
	projInfo.name = split[2]
}

// find tag between backtick, start & end is the position of backtick
func getLineTag(line string) (tag reflect.StructTag, start int, end int) {
	start = strings.Index(line, "`")
	end = strings.LastIndex(line, "`")
	if end <= start {
		return
	}
	tag = reflect.StructTag(line[start+1 : end])
	return
}

func getCommentWithoutTag(comment string) []string {
	var lines []string
	if comment == "" {
		return lines
	}
	split := strings.Split(strings.TrimRight(comment, "\n\r"), "\n")
	for _, line := range split {
		tag, _, _ := getLineTag(line)
		if tag == "" {
			lines = append(lines, line)
		}
	}
	return lines
}

func getTagsInComment(comment string) []reflect.StructTag {
	split := strings.Split(comment, "\n")
	var tagsInComment []reflect.StructTag
	for _, line := range split {
		tag, _, _ := getLineTag(line)
		if tag != "" {
			tagsInComment = append(tagsInComment, tag)
		}
	}
	return tagsInComment
}

func getTagValue(key string, tags []reflect.StructTag) string {
	for _, t := range tags {
		val := t.Get(key)
		if val != "" {
			return val
		}
	}
	return ""
}

// Is this field repeated?
func isRepeated(field *descriptor.FieldDescriptorProto) bool {
	return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REPEATED
}

func (t *bm) isMap(field *descriptor.FieldDescriptorProto) bool {
	if field.GetType() != descriptor.FieldDescriptorProto_TYPE_MESSAGE {
		return false
	}
	md := t.reg.MessageDefinition(field.GetTypeName())
	if md == nil || !md.Descriptor.GetOptions().GetMapEntry() {
		return false
	}
	return true
}

func (t *bm) generateToc(file *descriptor.FileDescriptorProto, service *descriptor.ServiceDescriptorProto) {
	for _, method := range service.Method {
		comment, _ := t.reg.MethodComments(file, service, method)
		tags := getTagsInComment(comment.Leading)
		_, path, newPath := t.getHttpInfo(file, service, method, tags)

		cleanComments := getCommentWithoutTag(comment.Leading)
		var title string
		if len(cleanComments) > 0 {
			title = cleanComments[0]
		}

		// 如果有老的路径，只显示老的路径文档
		if path != "" {
			anchor := strings.Replace(path, "/", "", -1)
			t.P(fmt.Sprintf("- [%s](#%s) %s", path, anchor, title))
		} else {
			anchor := strings.Replace(newPath, "/", "", -1)
			t.P(fmt.Sprintf("- [%s](#%s) %s", newPath, anchor, title))
		}
	}
}

func (t *bm) generateDoc(file *descriptor.FileDescriptorProto, service *descriptor.ServiceDescriptorProto) *plugin.CodeGeneratorResponse_File {
	resp := new(plugin.CodeGeneratorResponse_File)
	var name = goFileName(file, "."+lcFirst(service.GetName())+".md")
	resp.Name = &name
	t.P("<!-- package=" + file.GetPackage() + " -->")
	t.generateToc(file, service)
	for _, method := range service.Method {
		comment, err := t.reg.MethodComments(file, service, method)
		tags := getTagsInComment(comment.Leading)
		cleanComments := getCommentWithoutTag(comment.Leading)
		midwaresStr := getTagValue("midware", tags)
		needAuth := false
		if midwaresStr != "" {
			split := strings.Split(midwaresStr, ",")
			for _, m := range split {
				if m == "auth" {
					needAuth = true
					break
				}
			}
		}
		t.P()
		httpMethod, legacyPath, path := t.getHttpInfo(file, service, method, tags)
		if legacyPath != "" {
			path = legacyPath
		}
		t.P("## " + path)

		if err == nil {
			if len(cleanComments) == 0 {
				t.P(`### 无标题`)
			} else {
				t.P(`###`, strings.Join(cleanComments, "\n"))
			}
		}
		t.P()

		if needAuth {
			t.P(`> `, "需要登录")
			t.P()
		}

		t.P("#### 方法：" + httpMethod)
		t.P()

		t.genRequestParam(file, service, method)
		t.P("#### 响应")
		t.P()

		t.P("```javascript")
		t.P(`{`)
		t.P(`    "code": 0,`)
		t.P(`    "message": "ok",`)
		t.P(t.getExampleJson(file, service, method))
		t.P(`}`)
		t.P("```")
		t.P()
	}
	resp.Content = proto.String(t.output.String())
	t.output.Reset()
	return resp
}

func (t *bm) genRequestParam(
	file *descriptor.FileDescriptorProto,
	svc *descriptor.ServiceDescriptorProto,
	method *descriptor.MethodDescriptorProto) {
	md := t.reg.MessageDefinition(method.GetInputType())
	t.P(`#### 请求参数`)
	t.P()

	var outputs []string
	for i, f := range md.Descriptor.Field {
		if f.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE {
			// 如果有message 只能以json的方式显示参数了
			var buf = &[]string{}
			t.exampleJsonForMsg(md, file, buf, "", 0, "")
			j := strings.Join(*buf, "\n")
			t.P("```javascript")
			t.P(j)
			t.P("```")
			t.P()
			return
		}
		if i == 0 {
			outputs = append(outputs, `|参数名|必选|类型|描述|`)
			outputs = append(outputs, `|:---|:---|:---|:---|`)
		}
		fComment, _ := t.reg.FieldComments(file, md, f)
		var tags []reflect.StructTag
		{
			//get required info from gogoproto.moretags
			moretags := getMoreTags(f)
			if moretags != nil {
				tags = []reflect.StructTag{reflect.StructTag(*moretags)}
			}
		}
		if len(tags) == 0 {
			tags = getTagsInComment(fComment.Leading)
		}
		validateTag := getTagValue("validate", tags)
		var validateRules []string
		if validateTag != "" {
			validateRules = strings.Split(validateTag, ",")
		}
		required := false
		for _, rule := range validateRules {
			if rule == "required" {
				required = true
			}
		}
		requiredDesc := "是"
		if !required {
			requiredDesc = "否"
		}
		_, typeName := t.mockValueForField(f, tags)
		split := strings.Split(fComment.Leading, "\n")
		desc := ""
		for _, line := range split {
			if line != "" {
				tag, _, _ := getLineTag(line)
				if tag == "" {
					desc += line
				}
			}
		}
		outputs = append(outputs, fmt.Sprintf(`|%s|%s|%s|%s|`, getJsonTag(f), requiredDesc, typeName, desc))
	}
	for _, s := range outputs {
		t.P(s)
	}
	t.P()
}

func (t *bm) getExampleJson(file *descriptor.FileDescriptorProto,
	svc *descriptor.ServiceDescriptorProto,
	method *descriptor.MethodDescriptorProto) string {
	md := t.reg.MessageDefinition(method.GetOutputType())
	var buf = &[]string{}
	t.exampleJsonForMsg(md, file, buf, "data", 4, "")
	return strings.Join(*buf, "\n")
}

func makeIndentStr(i int) string {
	return strings.Repeat(" ", i)
}

func (t *bm) mockValueForField(field *descriptor.FieldDescriptorProto,
	tags []reflect.StructTag) (mockVal string, typeName string) {
	tagMock := getTagValue("mock", tags)
	mockVal = "\"unknown\""
	typeName = "unknown"
	switch field.GetType() {
	case descriptor.FieldDescriptorProto_TYPE_BOOL:
		if tagMock == "true" || tagMock == "false" {
			mockVal = tagMock
		} else {
			mockVal = "true"
		}
		typeName = "bool"
	case descriptor.FieldDescriptorProto_TYPE_DOUBLE,
		descriptor.FieldDescriptorProto_TYPE_FLOAT:
		mockVal = "0.1"
		if tagMock != "" {
			if _, err := strconv.ParseFloat(tagMock, 64); err == nil {
				mockVal = tagMock
			}
		}
		typeName = "float"
	case
		descriptor.FieldDescriptorProto_TYPE_INT64,
		descriptor.FieldDescriptorProto_TYPE_UINT64,
		descriptor.FieldDescriptorProto_TYPE_INT32,
		descriptor.FieldDescriptorProto_TYPE_FIXED64,
		descriptor.FieldDescriptorProto_TYPE_FIXED32,
		descriptor.FieldDescriptorProto_TYPE_ENUM,
		descriptor.FieldDescriptorProto_TYPE_UINT32,
		descriptor.FieldDescriptorProto_TYPE_SFIXED32,
		descriptor.FieldDescriptorProto_TYPE_SFIXED64,
		descriptor.FieldDescriptorProto_TYPE_SINT32,
		descriptor.FieldDescriptorProto_TYPE_SINT64:
		mockVal = "0"
		if tagMock != "" {
			if _, err := strconv.Atoi(tagMock); err == nil {
				mockVal = tagMock
			}
		}
		typeName = "integer"
	case
		descriptor.FieldDescriptorProto_TYPE_STRING,
		descriptor.FieldDescriptorProto_TYPE_BYTES:
		mockVal = `""`
		if tagMock != "" {
			mockVal = strconv.Quote(tagMock)
		}
		typeName = "string"
	}
	if isRepeated(field) {
		typeName = "多个" + typeName
	}
	return
}

func (t *bm) exampleJsonForMsg(
	msg *typemap.MessageDefinition,
	file *descriptor.FileDescriptorProto,
	buf *[]string, fieldName string, indent int, outEndComma string) {
	if fieldName == "" {
		*buf = append(*buf, makeIndentStr(indent)+"{")
	} else {
		*buf = append(*buf, makeIndentStr(indent)+fmt.Sprintf(`"%s": {`, fieldName))
	}
	num := len(msg.Descriptor.Field)
	for i, f := range msg.Descriptor.Field {
		isScalar := isScalar(f)
		fComment, _ := t.reg.FieldComments(file, msg, f)
		cleanComment := getCommentWithoutTag(fComment.Leading)
		for _, line := range cleanComment {
			if strings.Trim(line, " \t\n\r") != "" {
				*buf = append(*buf, makeIndentStr(indent+4)+"// "+line)
			}
		}

		endComma := ""
		if i < (num - 1) {
			endComma = ","
		}
		repeated := isRepeated(f)
		tags := getTagsInComment(fComment.Leading)
		if isScalar {
			mockVal, _ := t.mockValueForField(f, tags)

			if repeated {
				// "key" : [
				// 	value
				// ]
				*buf = append(*buf, makeIndentStr(indent+4)+`"`+getJsonTag(f)+`": [`)
				*buf = append(*buf, makeIndentStr(indent+8)+mockVal)
				*buf = append(*buf, makeIndentStr(indent+4)+`]`+endComma)
			} else {
				// "key" : value
				*buf = append(*buf, makeIndentStr(indent+4)+`"`+getJsonTag(f)+`": `+mockVal+endComma)
			}
		} else {
			isMap := t.isMap(f)
			if repeated {
				if isMap {
					*buf = append(*buf, makeIndentStr(indent+4)+`"`+getJsonTag(f)+`": {`)
				} else {
					*buf = append(*buf, makeIndentStr(indent+4)+`"`+getJsonTag(f)+`": [`)
				}
			}
			subMsg := t.reg.MessageDefinition(f.GetTypeName())
			if subMsg == nil {
				panic(fmt.Sprintf("%v%v", f.TypeName, f.Type))
			}
			nextIndent := indent + 4
			nextFname := getJsonTag(f)
			if repeated {
				nextIndent = indent + 8
				nextFname = ""
			}
			if isMap {
				mapKeyField := subMsg.Descriptor.Field[0]
				mapValueField := subMsg.Descriptor.Field[1]
				keyDesc := "mapKey"
				if mapKeyField.GetType() != descriptor.FieldDescriptorProto_TYPE_STRING {
					keyDesc = "1"
				}

				if mapValueField.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE {
					// "mapKey" : {
					// ...
					// }
					mapValueMsg := t.reg.MessageDefinition(mapValueField.GetTypeName())
					t.exampleJsonForMsg(mapValueMsg, file, buf, keyDesc, nextIndent, "")
				} else {
					// "mapKey" : "map value"
					val, _ := t.mockValueForField(mapValueField, tags)

					*buf = append(*buf, makeIndentStr(indent+8)+`"`+keyDesc+`": `+val)
				}
				*buf = append(*buf, makeIndentStr(indent+4)+`}`+endComma)
			} else {
				if repeated {
					t.exampleJsonForMsg(subMsg, file, buf, nextFname, nextIndent, "")
					*buf = append(*buf, makeIndentStr(indent+4)+`]`+endComma)
				} else {
					t.exampleJsonForMsg(subMsg, file, buf, nextFname, nextIndent, endComma)
				}
			}
		}
	}
	*buf = append(*buf, makeIndentStr(indent)+"}"+outEndComma)
}

// Is this field a scalar numeric type?
func isScalar(field *descriptor.FieldDescriptorProto) bool {
	if field.Type == nil {
		return false
	}
	switch *field.Type {
	case descriptor.FieldDescriptorProto_TYPE_DOUBLE,
		descriptor.FieldDescriptorProto_TYPE_FLOAT,
		descriptor.FieldDescriptorProto_TYPE_INT64,
		descriptor.FieldDescriptorProto_TYPE_UINT64,
		descriptor.FieldDescriptorProto_TYPE_INT32,
		descriptor.FieldDescriptorProto_TYPE_FIXED64,
		descriptor.FieldDescriptorProto_TYPE_FIXED32,
		descriptor.FieldDescriptorProto_TYPE_BOOL,
		descriptor.FieldDescriptorProto_TYPE_UINT32,
		descriptor.FieldDescriptorProto_TYPE_ENUM,
		descriptor.FieldDescriptorProto_TYPE_SFIXED32,
		descriptor.FieldDescriptorProto_TYPE_SFIXED64,
		descriptor.FieldDescriptorProto_TYPE_SINT32,
		descriptor.FieldDescriptorProto_TYPE_SINT64,
		descriptor.FieldDescriptorProto_TYPE_BYTES,
		descriptor.FieldDescriptorProto_TYPE_STRING:
		return true
	default:
		return false
	}
}

func (t *bm) registerPackageName(name string) (alias string) {
	alias = name
	i := 1
	for t.pkgNamesInUse[alias] {
		alias = name + strconv.Itoa(i)
		i++
	}
	t.pkgNamesInUse[alias] = true
	t.pkgs[name] = alias
	return alias
}

type visitor struct {
	funcMap map[string]bool
}

func (v visitor) Visit(n ast.Node) ast.Visitor {
	switch d := n.(type) {
	case *ast.FuncDecl:
		v.funcMap[d.Name.Name] = true
	}
	return v
}

// generateServiceImpl returns service implementation file service/{prefix}/service.go
// if file not exists
// else it returns nil
func (t *bm) generateServiceImpl(file *descriptor.FileDescriptorProto, svc *descriptor.ServiceDescriptorProto) *plugin.CodeGeneratorResponse_File {
	resp := new(plugin.CodeGeneratorResponse_File)
	prefix := t.getVersionPrefix()
	importPath := t.getPbImportPath(file.GetName())
	var alias = t.getPkgAlias()
	confPath := projInfo.importPath + "/conf"
	if projInfo.hasInternalPkg {
		confPath = projInfo.importPath + "/internal/conf"
	}
	name := "service/" + prefix + "/" + lcFirst(svc.GetName()) + ".go"
	if projInfo.hasInternalPkg {
		name = "internal/" + name
	}
	name = projInfo.pathRefToProj + name
	resp.Name = &name
	if _, err := os.Stat(name); !os.IsNotExist(err) {
		// Insert methods if file already exists
		fset := token.NewFileSet()
		astTree, err := parser.ParseFile(fset, name, nil, parser.ParseComments)
		if err != nil {
			panic("parse file error: " + name + " err: " + err.Error())
		}
		v := visitor{funcMap: map[string]bool{}}
		ast.Walk(v, astTree)

		t.output.Reset()
		buf, err := ioutil.ReadFile(name)
		if err != nil {
			panic("cannot read file:" + name)
		}
		t.P(string(buf))
		t.generateBmImpl(file, svc, v.funcMap)
		resp.Content = proto.String(t.formattedOutput())
		t.output.Reset()
		return resp
	}

	tplPkg := "service"
	if t.genPkgName[:1] == "v" {
		tplPkg = t.genPkgName
	}
	t.P(`package `, tplPkg)
	t.P()
	t.P(`import (`)
	t.P(`	`, alias, ` "`, importPath, `"`)
	t.P(`	"`, confPath, `"`)
	t.P(`	"context"`)
	t.P(`)`)
	for pkg, importPath := range t.deps {
		t.P(`import `, pkg, ` `, importPath)
	}
	svcStructName := serviceName(svc) + "Service"
	t.P(`// `, svcStructName, ` struct`)
	t.P(`type `, svcStructName, ` struct {`)
	t.P(`	conf   *conf.Config`)
	t.P(`	// optionally add other properties here, such as dao`)
	t.P(`	// dao *dao.Dao`)
	t.P(`}`)
	t.P()
	t.P(`//New`, svcStructName, ` init`)
	t.P(`func New`, svcStructName, `(c *conf.Config) (s *`, svcStructName, `) {`)
	t.P(`	s = &`, svcStructName, `{`)
	t.P(`		conf:   c,`)
	t.P(`	}`)
	t.P(`	return s`)
	t.P(`}`)

	comments, err := t.reg.ServiceComments(file, svc)
	if err == nil {
		t.printComments(comments)
	}
	t.P()
	t.generateBmImpl(file, svc, map[string]bool{})
	resp.Content = proto.String(t.formattedOutput())
	t.output.Reset()
	return resp
}

func (t *bm) generate(file *descriptor.FileDescriptorProto) *plugin.CodeGeneratorResponse_File {
	resp := new(plugin.CodeGeneratorResponse_File)
	if len(file.Service) == 0 {
		return nil
	}

	t.generateFileHeader(file, t.genPkgName)

	t.generateImports(file)

	t.generateMiddlewareInfo(file)
	for i, service := range file.Service {
		t.generateService(file, service, i)
		t.generateSingleRoute(file, service, i)
	}

	t.generateFileDescriptor(file)

	resp.Name = proto.String(goFileName(file, ".bm.go"))
	resp.Content = proto.String(t.formattedOutput())
	t.output.Reset()

	t.filesHandled++
	return resp
}

func (t *bm) generateMiddlewareInfo(file *descriptor.FileDescriptorProto) {
	t.P()
	for _, service := range file.Service {
		name := serviceName(service)
		for _, method := range service.Method {
			_, _, path := t.getHttpInfo(file, service, method, nil)
			t.P(`var Path`, name, methodName(method), ` = "`, path, `"`)
		}
		t.P()
	}
}
func (t *bm) generateFileHeader(file *descriptor.FileDescriptorProto, pkgName string) {
	t.P("// Code generated by protoc-gen-bm ", gen.Version, ", DO NOT EDIT.")
	t.P("// source: ", file.GetName())
	t.P()
	if t.filesHandled == 0 {
		t.P("/*")
		t.P("Package ", t.genPkgName, " is a generated blademaster stub package.")
		t.P("This code was generated with go-common/app/tool/bmgen/protoc-gen-bm ", gen.Version, ".")
		t.P()
		comment, err := t.reg.FileComments(file)
		if err == nil && comment.Leading != "" {
			for _, line := range strings.Split(comment.Leading, "\n") {
				line = strings.TrimPrefix(line, " ")
				// ensure we don't escape from the block comment
				line = strings.Replace(line, "*/", "* /", -1)
				t.P(line)
			}
			t.P()
		}
		t.P("It is generated from these files:")
		for _, f := range t.genFiles {
			t.P("\t", f.GetName())
		}
		t.P("*/")
	}
	t.P(`package `, pkgName)
	t.P()
}

func (t *bm) generateImports(file *descriptor.FileDescriptorProto) {
	if len(file.Service) == 0 {
		return
	}
	t.P(`import (`)
	//t.P(`	`,t.pkgs["context"], ` "context"`)
	t.P(`	"context"`)
	t.P()
	t.P(`	bm "go-common/library/net/http/blademaster"`)
	t.P(`	"go-common/library/net/http/blademaster/binding"`)

	t.P(`)`)
	// It's legal to import a message and use it as an input or output for a
	// method. Make sure to import the package of any such message. First, dedupe
	// them.
	deps := make(map[string]string) // Map of package name to quoted import path.
	ourImportPath := path.Dir(goFileName(file, ""))
	for _, s := range file.Service {
		for _, m := range s.Method {
			defs := []*typemap.MessageDefinition{
				t.reg.MethodInputDefinition(m),
				t.reg.MethodOutputDefinition(m),
			}
			for _, def := range defs {
				// By default, import path is the dirname of the Go filename.
				importPath := path.Dir(goFileName(def.File, ""))
				if importPath == ourImportPath {
					continue
				}
				if substitution, ok := t.importMap[def.File.GetName()]; ok {
					importPath = substitution
				}
				importPath = t.importPrefix + importPath
				pkg := t.goPackageName(def.File)
				deps[pkg] = strconv.Quote(importPath)
			}
		}
	}
	t.deps = deps
	for pkg, importPath := range deps {
		t.P(`import `, pkg, ` `, importPath)
	}
	if len(deps) > 0 {
		t.P()
	}
	t.P()
	t.P(`// to suppressed 'imported but not used warning'`)
	t.P(`var _ *bm.Context`)
	t.P(`var _ context.Context`)
	t.P(`var _ binding.StructValidator`)

}

// P forwards to g.gen.P, which prints output.
func (t *bm) P(args ...string) {
	for _, v := range args {
		t.output.WriteString(v)
	}
	t.output.WriteByte('\n')
}

// Big header comments to makes it easier to visually parse a generated file.
func (t *bm) sectionComment(sectionTitle string) {
	t.P()
	t.P(`// `, strings.Repeat("=", len(sectionTitle)))
	t.P(`// `, sectionTitle)
	t.P(`// `, strings.Repeat("=", len(sectionTitle)))
	t.P()
}

func (t *bm) generateService(file *descriptor.FileDescriptorProto, service *descriptor.ServiceDescriptorProto, index int) {
	servName := serviceName(service)

	t.sectionComment(servName + ` Interface`)
	t.generateBMInterface(file, service)

}

// import project/api的路径
func (t *bm) getPbImportPath(filename string) (importPath string) {
	wd, err := os.Getwd()
	if err != nil {
		panic("cannot get working directory")
	}
	index := strings.Index(wd, "go-common")
	if index == -1 {
		gen.Fail("must use inside go-common")
	}
	dir := filepath.Dir(filename)
	if dir != "." {
		importPath = wd + "/" + dir
	} else {
		importPath = wd
	}
	importPath = importPath[index:]
	return
}

// getProjPath return project path relative to GOPATH
func (t *bm) getProjPath() string {
	wd, err := os.Getwd()
	if err != nil {
		panic("cannot get working directory")
	}
	index := strings.Index(wd, "go-common")
	if index == -1 {
		gen.Fail("must use inside go-common")
	}
	projPkgPath := wd[index:]
	return projPkgPath
}

func lcFirst(str string) string {
	for i, v := range str {
		return string(unicode.ToLower(v)) + str[i+1:]
	}
	return ""
}

// TODO rename
func (t *bm) getLegacyPathPrefix(
	svc *descriptor.ServiceDescriptorProto, pathParts []string, isInternal bool) (uriPrefix string) {
	var parts []string
	parts = append(parts, pathParts[0])
	if isInternal {
		parts = append(parts, "internal")
	}
	parts = append(parts, pathParts[1:]...)
	uriPrefix = fmt.Sprintf("/x%s/%s", strings.Join(parts, "/"), lcFirst(svc.GetName()))
	return
}

func (t *bm) getHttpInfo(
	file *descriptor.FileDescriptorProto,
	service *descriptor.ServiceDescriptorProto,
	method *descriptor.MethodDescriptorProto,
	tags []reflect.StructTag,
) (httpMethod string, oldPath string, newPath string) {
	googleOptionInfo, err := ParseBMMethod(method)
	if err == nil {
		httpMethod = strings.ToUpper(googleOptionInfo.Method)
		p := googleOptionInfo.PathPattern
		if p != "" {
			oldPath = p
			newPath = p
			return
		}
	}

	if httpMethod == "" {
		// resolve http method
		httpMethod = getTagValue("method", tags)
		if httpMethod == "" {
			httpMethod = "GET"
		} else {
			httpMethod = strings.ToUpper(httpMethod)
		}
	}

	isLegacy, parts := t.convertLegacyPackage(file.GetPackage())
	if isLegacy {
		apiInternal := getTagValue("internal", tags) == "true"
		pathPrefix := t.getLegacyPathPrefix(service, parts, apiInternal)
		oldPath = pathPrefix + `/` + method.GetName()
	}
	newPath = "/" + file.GetPackage() + "." + service.GetName() + "/" + method.GetName()
	return
}

// 返回空，则不用考虑历史package
// 如果非空，则表示按照返回的pathParts做url规则
func (t *bm) convertLegacyPackage(pkgName string) (isLegacy bool, pathParts []string) {
	var splits = strings.Split(pkgName, ".")
	var remain []string
	if len(splits) >= 2 {
		splits = splits[0:2]
		remain = splits[2:]
	}
	var pkgPrefix = strings.Join(splits, ".")
	legacyPkg, isLegacy := legacyPathMapping[pkgPrefix]
	if isLegacy {
		legacyPkg = strings.Replace(pkgName, pkgPrefix, legacyPkg, 1)
		pathParts = append(pathParts, strings.Split(legacyPkg, ".")...)
		pathParts = append(pathParts, remain...)
	}
	return
}

func (t *bm) generateSingleRoute(
	file *descriptor.FileDescriptorProto,
	service *descriptor.ServiceDescriptorProto,
	index int) {
	// old mode is generate xx.route.go in the http pkg
	// new mode is generate route code in the same .bm.go
	// route rule /x{department}/{project-name}/{path_prefix}/method_name
	// generate each route method
	servName := serviceName(service)
	versionPrefix := t.getVersionPrefix()
	svcName := lcFirst(stringutils.CamelCase(versionPrefix)) + servName + "Svc"
	t.P(`var `, svcName, ` `, servName, `BMServer`)

	type methodInfo struct {
		httpMethod    string
		midwares      []string
		routeFuncName string
		path          string
		legacyPath    string
		methodName    string
	}
	var methList []methodInfo
	var allMidwareMap = make(map[string]bool)
	var isLegacyPkg = false
	for _, method := range service.Method {
		var httpMethod string
		var midwares []string
		comments, _ := t.reg.MethodComments(file, service, method)
		tags := getTagsInComment(comments.Leading)
		if getTagValue("dynamic", tags) == "true" {
			continue
		}
		httpMethod, legacyPath, path := t.getHttpInfo(file, service, method, tags)
		if legacyPath != "" {
			isLegacyPkg = true
		}

		midStr := getTagValue("midware", tags)
		if midStr != "" {
			midwares = strings.Split(midStr, ",")
			for _, m := range midwares {
				allMidwareMap[m] = true
			}
		}

		methName := methodName(method)
		inputType := t.goTypeName(method.GetInputType())

		routeName := lcFirst(stringutils.CamelCase(servName) +
			stringutils.CamelCase(methName))

		methList = append(methList, methodInfo{
			httpMethod:    httpMethod,
			midwares:      midwares,
			routeFuncName: routeName,
			path:          path,
			legacyPath:    legacyPath,
			methodName:    method.GetName(),
		})

		t.P(fmt.Sprintf("func %s (c *bm.Context) {", routeName))
		t.P(`	p := new(`, inputType, `)`)
		t.P(`	if err := c.BindWith(p, binding.Default(c.Request.Method, c.Request.Header.Get("Content-Type"))); err != nil {`)
		t.P(`		return`)
		t.P(`	}`)
		t.P(`	resp, err := `, svcName, `.`, methName, `(c, p)`)
		t.P(`	c.JSON(resp, err)`)
		t.P(`}`)
		t.P(``)
	}

	// generate route group
	var midList []string
	for m := range allMidwareMap {
		midList = append(midList, m+" bm.HandlerFunc")
	}

	sort.Strings(midList)

	// 注册老的路由的方法
	if isLegacyPkg {
		funcName := `Register` + stringutils.CamelCase(versionPrefix) + servName + `Service`
		t.P(`// `, funcName, ` Register the blademaster route with middleware map`)
		t.P(`// midMap is the middleware map, the key is defined in proto`)
		t.P(`func `, funcName, `(e *bm.Engine, svc `, servName, "BMServer, midMap map[string]bm.HandlerFunc)", ` {`)
		var keys []string
		for m := range allMidwareMap {
			keys = append(keys, m)
		}
		// to keep generated code consistent
		sort.Strings(keys)
		for _, m := range keys {
			t.P(m, ` := midMap["`, m, `"]`)
		}

		t.P(svcName, ` = svc`)
		for _, methInfo := range methList {
			var midArgStr string
			if len(methInfo.midwares) == 0 {
				midArgStr = ""
			} else {
				midArgStr = strings.Join(methInfo.midwares, ", ") + ", "
			}
			t.P(`e.`, methInfo.httpMethod, `("`, methInfo.legacyPath, `", `, midArgStr, methInfo.routeFuncName, `)`)
		}
		t.P(`	}`)
	}
	// 新的注册路由的方法
	var bmFuncName = fmt.Sprintf("Register%sBMServer", servName)
	t.P(`// `, bmFuncName, ` Register the blademaster route`)
	t.P(`func `, bmFuncName, `(e *bm.Engine, server `, servName, `BMServer) {`)
	t.P(svcName, ` = server`)
	for _, methInfo := range methList {
		t.P(`e.`, methInfo.httpMethod, `("`, methInfo.path, `",`, methInfo.routeFuncName, ` )`)
	}
	t.P(`	}`)
}

func (t *bm) generateBMInterface(file *descriptor.FileDescriptorProto, service *descriptor.ServiceDescriptorProto) {
	servName := serviceName(service)

	comments, err := t.reg.ServiceComments(file, service)
	if err == nil {
		t.printComments(comments)
	}
	t.P(`type `, servName, `BMServer interface {`)
	for _, method := range service.Method {
		t.generateSignature(file, service, method, comments)
		t.P()
	}
	t.P(`}`)
}

// pb包的别名
// 用户生成service实现模板时，对pb文件的引用
// 如果是v*的package 则为v*pb
// 其他为pb
func (t *bm) getPkgAlias() string {
	if t.genPkgName == "" {
		return "pb"
	}
	if t.genPkgName[:1] == "v" {
		return t.genPkgName + "pb"
	}
	return "pb"
}

// 如果是v*开始的 返回v*
// 否则返回空
func (t *bm) getVersionPrefix() string {
	if t.genPkgName == "" {
		return ""
	}
	if t.genPkgName[:1] == "v" {
		return t.genPkgName
	}
	return ""
}

func (t *bm) generateBmImpl(file *descriptor.FileDescriptorProto, service *descriptor.ServiceDescriptorProto,
	existMap map[string]bool) {
	var pkgName = t.getPkgAlias()
	svcName := serviceName(service) + "Service"

	for _, method := range service.Method {
		methName := methodName(method)
		if existMap[methName] {
			continue
		}
		comments, err := t.reg.MethodComments(file, service, method)
		tags := getTagsInComment(comments.Leading)
		respDynamic := getTagValue("dynamic_resp", tags) == "true"
		genImp := func(dynamicRet bool) {
			t.P(`// `, methName, " implementation")
			if err == nil {
				t.printComments(comments)
			}
			outputType := t.goTypeName(method.GetOutputType())
			inputType := t.goTypeName(method.GetInputType())
			var body string
			var ownPkg = t.isOwnPackage(method.GetOutputType())
			var respType string
			if ownPkg {
				respType = pkgName + "." + outputType
			} else {
				respType = outputType
			}
			if dynamicRet {
				body = fmt.Sprintf(`func (s *%s) %s(ctx context.Context, req *%s.%s) (resp interface{}, err error) {`,
					svcName, methName, pkgName, inputType)
			} else {
				body = fmt.Sprintf(`func (s *%s) %s(ctx context.Context, req *%s.%s) (resp *%s, err error) {`,
					svcName, methName, pkgName, inputType, respType)
			}

			t.P(body)
			t.P(fmt.Sprintf("resp = &%s{}", respType))
			t.P(`	return`)
			t.P(`}`)
			t.P()
		}
		genImp(respDynamic)
	}
}

func (t *bm) generateSignature(file *descriptor.FileDescriptorProto,
	service *descriptor.ServiceDescriptorProto,
	method *descriptor.MethodDescriptorProto,
	comments typemap.DefinitionComments) {
	comments, err := t.reg.MethodComments(file, service, method)

	methName := methodName(method)
	outputType := t.goTypeName(method.GetOutputType())
	inputType := t.goTypeName(method.GetInputType())
	tags := getTagsInComment(comments.Leading)
	if getTagValue("dynamic", tags) == "true" {
		return
	}

	if err == nil {
		t.printComments(comments)
	}

	respDynamic := getTagValue("dynamic_resp", tags) == "true"
	if respDynamic {
		t.P(fmt.Sprintf(`	%s(ctx context.Context, req *%s) (resp interface{}, err error)`,
			methName, inputType))
	} else {
		t.P(fmt.Sprintf(`	%s(ctx context.Context, req *%s) (resp *%s, err error)`,
			methName, inputType, outputType))
	}
}

func (t *bm) generateFileDescriptor(file *descriptor.FileDescriptorProto) {
	// Copied straight of of protoc-gen-go, which trims out comments.
	pb := proto.Clone(file).(*descriptor.FileDescriptorProto)
	pb.SourceCodeInfo = nil

	b, err := proto.Marshal(pb)
	if err != nil {
		gen.Fail(err.Error())
	}

	var buf bytes.Buffer
	w, _ := gzip.NewWriterLevel(&buf, gzip.BestCompression)
	w.Write(b)
	w.Close()
	buf.Bytes()
}

func (t *bm) printComments(comments typemap.DefinitionComments) bool {
	text := strings.TrimSuffix(comments.Leading, "\n")
	if len(strings.TrimSpace(text)) == 0 {
		return false
	}
	split := strings.Split(text, "\n")
	for _, line := range split {
		t.P("// ", strings.TrimPrefix(line, " "))
	}
	return len(split) > 0
}

// Given a protobuf name for a Message, return the Go name we will use for that
// type, including its package prefix.
func (t *bm) goTypeName(protoName string) string {
	def := t.reg.MessageDefinition(protoName)
	if def == nil {
		gen.Fail("could not find message for", protoName)
	}

	var prefix string
	if pkg := t.goPackageName(def.File); pkg != t.genPkgName {
		prefix = pkg + "."
	}

	var name string
	for _, parent := range def.Lineage() {
		name += parent.Descriptor.GetName() + "_"
	}
	name += def.Descriptor.GetName()
	return prefix + name
}

func (t *bm) isOwnPackage(protoName string) bool {
	def := t.reg.MessageDefinition(protoName)
	if def == nil {
		gen.Fail("could not find message for", protoName)
	}
	pkg := t.goPackageName(def.File)
	return pkg == t.genPkgName
}

func (t *bm) goPackageName(file *descriptor.FileDescriptorProto) string {
	return t.fileToGoPackageName[file]
}

func (t *bm) formattedOutput() string {
	// Reformat generated code.
	fset := token.NewFileSet()
	raw := t.output.Bytes()
	ast, err := parser.ParseFile(fset, "", raw, parser.ParseComments)
	if err != nil {
		// Print out the bad code with line numbers.
		// This should never happen in practice, but it can while changing generated code,
		// so consider this a debugging aid.
		var src bytes.Buffer
		s := bufio.NewScanner(bytes.NewReader(raw))
		for line := 1; s.Scan(); line++ {
			fmt.Fprintf(&src, "%5d\t%s\n", line, s.Bytes())
		}
		gen.Fail("bad Go source code was generated:", err.Error(), "\n"+src.String())
	}

	out := bytes.NewBuffer(nil)
	err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(out, fset, ast)
	if err != nil {
		gen.Fail("generated Go source code could not be reformatted:", err.Error())
	}

	return out.String()
}

func serviceName(service *descriptor.ServiceDescriptorProto) string {
	return stringutils.CamelCase(service.GetName())
}

func methodName(method *descriptor.MethodDescriptorProto) string {
	return stringutils.CamelCase(method.GetName())
}

func fileDescSliceContains(slice []*descriptor.FileDescriptorProto, f *descriptor.FileDescriptorProto) bool {
	for _, sf := range slice {
		if f == sf {
			return true
		}
	}
	return false
}

// deduceGenPkgName figures out the go package name to use for generated code.
// Will try to use the explicit go_package setting in a file (if set, must be
// consistent in all files). If no files have go_package set, then use the
// protobuf package name (must be consistent in all files)
func deduceGenPkgName(genFiles []*descriptor.FileDescriptorProto) (string, error) {
	var genPkgName string
	for _, f := range genFiles {
		name, explicit := goPackageName(f)
		if explicit {
			name = stringutils.CleanIdentifier(name)
			if genPkgName != "" && genPkgName != name {
				// Make sure they're all set consistently.
				return "", errors.Errorf("files have conflicting go_package settings, must be the same: %q and %q", genPkgName, name)
			}
			genPkgName = name
		}
	}
	if genPkgName != "" {
		return genPkgName, nil
	}

	// If there is no explicit setting, then check the implicit package name
	// (derived from the protobuf package name) of the files and make sure it's
	// consistent.
	for _, f := range genFiles {
		name, _ := goPackageName(f)
		name = stringutils.CleanIdentifier(name)
		if genPkgName != "" && genPkgName != name {
			return "", errors.Errorf("files have conflicting package names, must be the same or overridden with go_package: %q and %q", genPkgName, name)
		}
		genPkgName = name
	}

	// All the files have the same name, so we're good.
	return genPkgName, nil
}