/
main.go
131 lines (110 loc) · 3.66 KB
/
main.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
121
122
123
124
125
126
127
128
129
130
131
package main
import (
"context"
"flag"
"fmt"
"github.com/go-kit/kit/log"
kitprometheus "github.com/go-kit/kit/metrics/prometheus"
kitzipkin "github.com/go-kit/kit/tracing/zipkin"
"github.com/openzipkin/zipkin-go"
stdprometheus "github.com/prometheus/client_golang/prometheus"
zipkinhttp "github.com/openzipkin/zipkin-go/reporter/http"
"golang.org/x/time/rate"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
var (
consulHost = flag.String("consul.host", "", "consul ip address")
consulPort = flag.String("consul.port", "", "consul port")
serviceHost = flag.String("service.host", "", "service ip address")
servicePort = flag.String("service.port", "", "service port")
zipkinURL = flag.String("zipkin.url", "http://192.168.192.146:9411/api/v2/spans", "Zipkin server url")
)
flag.Parse()
ctx := context.Background()
errChan := make(chan error)
var logger log.Logger
{
logger = log.NewLogfmtLogger(os.Stderr)
logger = log.With(logger, "ts", log.DefaultTimestampUTC)
logger = log.With(logger, "caller", log.DefaultCaller)
}
fieldKeys := []string{"method"}
requestCount := kitprometheus.NewCounterFrom(stdprometheus.CounterOpts{
Namespace: "raysonxin",
Subsystem: "arithmetic_service",
Name: "request_count",
Help: "Number of requests received.",
}, fieldKeys)
requestLatency := kitprometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
Namespace: "raysonxin",
Subsystem: "arithemetic_service",
Name: "request_latency",
Help: "Total duration of requests in microseconds.",
}, fieldKeys)
var zipkinTracer *zipkin.Tracer
{
var (
err error
hostPort = *serviceHost + ":" + *servicePort
serviceName = "arithmetic-service"
useNoopTracer = (*zipkinURL == "")
reporter = zipkinhttp.NewReporter(*zipkinURL)
)
defer reporter.Close()
zEP, _ := zipkin.NewEndpoint(serviceName, hostPort)
zipkinTracer, err = zipkin.NewTracer(
reporter, zipkin.WithLocalEndpoint(zEP), zipkin.WithNoopTracer(useNoopTracer),
)
if err != nil {
logger.Log("err", err)
os.Exit(1)
}
if !useNoopTracer {
logger.Log("tracer", "Zipkin", "type", "Native", "URL", *zipkinURL)
}
}
//add ratelimit,refill every second,set capacity 3
ratebucket := rate.NewLimiter(rate.Every(time.Second*1), 100)
var svc Service
svc = ArithmeticService{}
// add logging middleware to service
svc = LoggingMiddleware(logger)(svc)
svc = Metrics(requestCount, requestLatency)(svc)
endpoint := MakeArithmeticEndpoint(svc)
endpoint = NewTokenBucketLimitterWithBuildIn(ratebucket)(endpoint)
endpoint = kitzipkin.TraceEndpoint(zipkinTracer, "calculate-endpoint")(endpoint)
//创建健康检查的Endpoint
healthEndpoint := MakeHealthCheckEndpoint(svc)
healthEndpoint = NewTokenBucketLimitterWithBuildIn(ratebucket)(healthEndpoint)
healthEndpoint = kitzipkin.TraceEndpoint(zipkinTracer, "health-endpoint")(healthEndpoint)
//把算术运算Endpoint和健康检查Endpoint封装至ArithmeticEndpoints
endpts := ArithmeticEndpoints{
ArithmeticEndpoint: endpoint,
HealthCheckEndpoint: healthEndpoint,
}
//创建http.Handler
r := MakeHttpHandler(ctx, endpts, zipkinTracer, logger)
//创建注册对象
registar := Register(*consulHost, *consulPort, *serviceHost, *servicePort, logger)
go func() {
fmt.Println("Http Server start at port:" + *servicePort)
//启动前执行注册
registar.Register()
handler := r
errChan <- http.ListenAndServe(":"+*servicePort, handler)
}()
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
errChan <- fmt.Errorf("%s", <-c)
}()
error := <-errChan
//服务退出取消注册
registar.Deregister()
fmt.Println(error)
}