forked from linchao0815/protoc-gen-go-asynq
/
template.go
120 lines (105 loc) · 3.05 KB
/
template.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package main
import (
"bytes"
"strings"
"text/template"
)
var asynqTemplate = `
{{$svrType := .ServiceType}}
{{$svrName := .ServiceName}}
type {{.ServiceType}}JobServer interface {
{{- range .MethodSets}}
{{.Name}}(context.Context, *{{.Request}}) (error)
{{- end}}
}
func Register{{.ServiceType}}JobServer(mux *asynq.ServeMux, srv {{.ServiceType}}JobServer) {
{{- range .Methods}}
mux.HandleFunc("{{.Typename}}", _{{$svrType}}_{{.Name}}_Job_Handler(srv))
{{- end}}
}
{{range .Methods}}
func _{{$svrType}}_{{.Name}}_Job_Handler(srv {{$svrType}}JobServer) func(context.Context, *asynq.Task) error {
return func(ctx context.Context, task *asynq.Task) error {
var in {{.Request}}
if err := json.Unmarshal(task.Payload(), &in); err != nil {
return log.Errorln(task.Type(),log.Any("request",in),log.NewWhy(err))
}
err := srv.{{.Name}}(ctx, &in)
if err != nil{
err=log.Errorln(task.Type(),log.Any("request",in),log.NewWhy(err))
}else{
log.Println(task.Type(),log.Any("request",in))
}
return err
}
}
{{end}}
type {{.ServiceType}}SvcJob struct {}
var {{.ServiceType}}Job {{.ServiceType}}SvcJob
{{range .MethodSets}}
func (j *{{$svrType}}SvcJob) {{.Name}}(in *{{.Request}}, opts ...asynq.Option) (*asynq.Task, error) {
payload, err := json.Marshal(in)
if err != nil {
return nil, err
}
task := asynq.NewTask("{{.Typename}}", payload, opts...)
return task, nil
}
{{end}}
type {{.ServiceType}}JobClient interface {
{{- range .MethodSets}}
{{.Name}}(ctx context.Context, req *{{.Request}}, opts ...asynq.Option) (info *asynq.TaskInfo, err error)
{{- end}}
}
type {{.ServiceType}}JobClientImpl struct{
cc *asynq.Client
}
func New{{.ServiceType}}JobClient (client *asynq.Client) {{.ServiceType}}JobClient {
return &{{.ServiceType}}JobClientImpl{client}
}
{{range .MethodSets}}
func (c *{{$svrType}}JobClientImpl) {{.Name}}(ctx context.Context, in *{{.Request}}, opts ...asynq.Option) (*asynq.TaskInfo, error) {
task, err := {{$svrType}}Job.{{.Name}}(in, opts...)
if err != nil {
return nil, log.Errorln("{{$svrType}}Job.{{.Name}}", log.Any("request", in),log.NewWhy(err))
}
log.Println("{{$svrType}}Job.{{.Name}}", log.Any("request", in))
info, err := c.cc.Enqueue(task)
if err != nil {
return nil, log.Errorln("{{$svrType}}Job.{{.Name}} Enqueue", log.Any("request", in),log.NewWhy(err))
}
return info, nil
}
{{end}}
`
type serviceDesc struct {
ServiceType string // Greeter
ServiceName string // helloworld.Greeter
Metadata string // api/helloworld/helloworld.proto
Methods []*methodDesc
MethodSets map[string]*methodDesc
}
type methodDesc struct {
// method
Name string
Num int
Request string
Reply string
// asynq rule
Typename string
}
func (s *serviceDesc) execute() string {
s.MethodSets = make(map[string]*methodDesc)
for _, m := range s.Methods {
s.MethodSets[m.Name] = m
}
buf := new(bytes.Buffer)
tmpl, err := template.New("asynq").Parse(strings.TrimSpace(asynqTemplate))
if err != nil {
panic(err)
}
if err := tmpl.Execute(buf, s); err != nil {
panic(err)
}
return strings.Trim(buf.String(), "\r\n")
}