5.3 Swagger了解一下#

1
go get -u github.com/jteeuwen/go-bindata/...

1
go-bindata --nocompress -pkg swagger -o pkg/ui/data/swagger/datafile.go third_party/swagger-ui/...

1
go get github.com/elazarl/go-bindata-assetfs/...

1
package cmd
2

3
import (
4
  "log"
5

6
  "github.com/spf13/cobra"
7

8
  "grpc-hello-world/server"
9
)
10

11
var serverCmd = &cobra.Command{
12
  Use:   "server",
13
  Short: "Run the gRPC hello-world server",
14
  Run: func(cmd *cobra.Command, args []string) {
15
    defer func() {
16
      if err := recover(); err != nil {
17
        log.Println("Recover error : %v", err)
18
      }
19
    }()
20

21
    server.Run()
22
  },
23
}
24

25
func init() {
26
  serverCmd.Flags().StringVarP(&server.ServerPort, "port", "p", "50052", "server port")
27
  serverCmd.Flags().StringVarP(&server.CertPemPath, "cert-pem", "", "./conf/certs/server.pem", "cert-pem path")
28
  serverCmd.Flags().StringVarP(&server.CertKeyPath, "cert-key", "", "./conf/certs/server.key", "cert-key path")
29
  serverCmd.Flags().StringVarP(&server.CertServerName, "cert-server-name", "", "grpc server name", "server's hostname")
30
  serverCmd.Flags().StringVarP(&server.SwaggerDir, "swagger-dir", "", "proto", "path to the directory which contains swagger definitions")
31

32
  rootCmd.AddCommand(serverCmd)
33
}

1
package server
2

3
import (
4
    "crypto/tls"
5
    "net"
6
    "net/http"
7
    "log"
8
    "strings"
9
    "path"
10

11
    "golang.org/x/net/context"
12
    "google.golang.org/grpc"
13
    "google.golang.org/grpc/credentials"
14
    "github.com/grpc-ecosystem/grpc-gateway/runtime"
15
    "github.com/elazarl/go-bindata-assetfs"
16

17
    pb "grpc-hello-world/proto"
18
    "grpc-hello-world/pkg/util"
19
    "grpc-hello-world/pkg/ui/data/swagger"
20
)
21

22
var (
23
    ServerPort string
24
    CertServerName string
25
    CertPemPath string
26
    CertKeyPath string
27
    SwaggerDir string
28
    EndPoint string
29

30
    tlsConfig *tls.Config
31
)
32

33
func Run() (err error) {
34
    EndPoint = ":" + ServerPort
35
    tlsConfig = util.GetTLSConfig(CertPemPath, CertKeyPath)
36

37
    conn, err := net.Listen("tcp", EndPoint)
38
    if err != nil {
39
        log.Printf("TCP Listen err:%v\n", err)
40
    }
41

42
    srv := newServer(conn)
43

44
    log.Printf("gRPC and https listen on: %s\n", ServerPort)
45

46
    if err = srv.Serve(util.NewTLSListener(conn, tlsConfig)); err != nil {
47
        log.Printf("ListenAndServe: %v\n", err)
48
    }
49

50
    return err
51
}
52

53
func newServer(conn net.Listener) (*http.Server) {
54
    grpcServer := newGrpc()
55
    gwmux, err := newGateway()
56
    if err != nil {
57
        panic(err)
58
    }
59

60
    mux := http.NewServeMux()
61
    mux.Handle("/", gwmux)
62
    mux.HandleFunc("/swagger/", serveSwaggerFile)
63
    serveSwaggerUI(mux)
64

65
    return &http.Server{
66
        Addr:      EndPoint,
67
        Handler:   util.GrpcHandlerFunc(grpcServer, mux),
68
        TLSConfig: tlsConfig,
69
    }
70
}
71

72
func newGrpc() *grpc.Server {
73
    creds, err := credentials.NewServerTLSFromFile(CertPemPath, CertKeyPath)
74
    if err != nil {
75
        panic(err)
76
    }
77

78
    opts := []grpc.ServerOption{
79
        grpc.Creds(creds),
80
    }
81
    server := grpc.NewServer(opts...)
82

83
    pb.RegisterHelloWorldServer(server, NewHelloService())
84

85
    return server
86
}
87

88
func newGateway() (http.Handler, error) {
89
    ctx := context.Background()
90
    dcreds, err := credentials.NewClientTLSFromFile(CertPemPath, CertServerName)
91
    if err != nil {
92
        return nil, err
93
    }
94
    dopts := []grpc.DialOption{grpc.WithTransportCredentials(dcreds)}
95

96
    gwmux := runtime.NewServeMux()
97
    if err := pb.RegisterHelloWorldHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
98
        return nil, err
99
    }
100

101
    return gwmux, nil
102
}
103

104
func serveSwaggerFile(w http.ResponseWriter, r *http.Request) {
105
      if ! strings.HasSuffix(r.URL.Path, "swagger.json") {
106
        log.Printf("Not Found: %s", r.URL.Path)
107
        http.NotFound(w, r)
108
        return
109
    }
110

111
    p := strings.TrimPrefix(r.URL.Path, "/swagger/")
112
    p = path.Join(SwaggerDir, p)
113

114
    log.Printf("Serving swagger-file: %s", p)
115

116
    http.ServeFile(w, r, p)
117
}
118

119
func serveSwaggerUI(mux *http.ServeMux) {
120
    fileServer := http.FileServer(&assetfs.AssetFS{
121
        Asset:    swagger.Asset,
122
        AssetDir: swagger.AssetDir,
123
        Prefix:   "third_party/swagger-ui",
124
    })
125
    prefix := "/swagger-ui/"
126
    mux.Handle(prefix, http.StripPrefix(prefix, fileServer))
127
}