35、未雨绸缪：怎样通过静态与动态代码扫描保证代码质量

func logWrapper(log *zap.Logger) server.HandlerWrapper {
	return func(fn server.HandlerFunc) server.HandlerFunc {
		return func(ctx context.Context, req server.Request, rsp interface{}) error {
			log.Info("recieve request",
				zap.String("method", req.Method()),
				zap.String("Service", req.Service()),
				zap.Reflect("request param:", req.Body()),
			)
			err := fn(ctx, req, rsp)
			return err
		}
	}
}

service := micro.NewService(
		...
		micro.WrapHandler(logWrapper(logger)),
	)

{"level":"INFO","ts":"2022-11-28T00:29:28.287+0800","caller":"crawler/main.go:148","msg":"recieve request","method":"Greeter.Hello","Service":"go.micro.server.worker","request param:":{}}

> golangci-lint help linters

golangci-lint run

golangci-lint run ./...

golangci-lint run dir1 dir2/... dir3/file1.go

golangci-lint help linters

run:
    tests: false
    skip-dirs:
        - vendor

linters-settings:
    funlen:
        # Checks the number of lines in a function.
        # If lower than 0, disable the check.
        # Default: 60
        lines: 120
        # Checks the number of statements in a function.
        # If lower than 0, disable the check.
        # Default: 40
        statements: -1

# list all linters by run `golangci-lint help linters`
linters:
    enable-all: true
    disable:
        # gochecknoglobals: Checks that no globals are present in Go code
        - gochecknoglobals
        # gochecknoinits: Checks that no init functions are present in Go code
        - gochecknoinits
        # Checks that errors returned from external packages are wrapped
        - wrapcheck
        # checks that the length of a variable's name matches its scope
        - varnamelen
        # Checks the struct tags.
        - tagliatelle
        # An analyzer to detect magic numbers.
        - gomnd
				...

sqldb/option.go:9:2: struct field `sqlUrl` should be `sqlURL` (golint)
        sqlUrl string

engine/schedule.go:242:4: branch statements should not be cuddled if block has more than two lines (wsl)
                        continue

// race.go
var count = 0
func add() {
	count++
}
func main() {
	go add()
	go add()
}

func save(g *data){
	saveToRedis(g)
}
func main() {
	var a map[int]data
	for _, k := range a{
		go save(&k)
	}
}

$ go test -race mypkg
$ go run -race mysrc.go
$ go build -race mycmd
$ go install -race mypkg

» go run -race race.go
==================
WARNING: DATA RACE
Read at 0x00000115c1f8 by goroutine 7:
main.add()
bookcode/concurrence_control/race.go:5 +0x3a
Previous write at 0x00000115c1f8 by goroutine 6:
main.add()
bookcode/concurrence_control/race.go:5 +0x56

{
  "hosts": {
    "database": {
      "address": "10.0.0.2",
      "port": 3306
    },
    "cache": {
      "address": "10.0.0.2",
      "port": 6379
    }
  }
}

package main

import (
	...
	"go-micro.dev/v4/config"
	"go-micro.dev/v4/config/source/file"
)
func main() {

	// 导入数据
	err := config.Load(file.NewSource(
		file.WithPath("config.json"),
	))
	if err != nil {
		fmt.Println(err)
	}
	type Host struct {
		Address string `json:"address"`
		Port    int    `json:"port"`
	}

	var host Host
	// 获取hosts.database下的数据，并解析为host结构
	config.Get("hosts", "database").Scan(&host)

	fmt.Println(host)

	w, err := config.Watch("hosts", "database")
	if err != nil {
		fmt.Println(err)
	}

	// 等待配置文件更新
	v, err := w.Next()
	if err != nil {
		fmt.Println(err)
	}

	v.Scan(&host)
	fmt.Println(host)
}

enc := toml.NewEncoder()
cfg, err := config.NewConfig(config.WithReader(json.NewReader(reader.WithEncoder(enc))))
err = cfg.Load(file.NewSource(
   file.WithPath("config.toml"),
   source.WithEncoder(enc),
))

logLevel = "debug"

Tasks = [
    {Name = "douban_book_list",WaitTime = 2,Reload = true,MaxDepth = 5,Fetcher = "browser",Limits=[{EventCount = 1,EventDur=2,Bucket=1},{EventCount = 20,EventDur=60,Bucket=20}],Cookie = "xxx"},
    {Name = "xxx"},
]

[fetcher]
timeout = 3000
proxy = ["<http://127.0.0.1:8888>", "<http://127.0.0.1:8888>"]

[storage]
sqlURL = "root:123456@tcp(127.0.0.1:3326)/crawler?charset=utf8"

[GRPCServer]
HTTPListenAddress = ":8080"
GRPCListenAddress = ":9090"
ID = "1"
RegistryAddress = ":2379"
RegisterTTL = 60
RegisterInterval = 15
ClientTimeOut   = 10
Name = "go.micro.server.worker"

VERSION := v1.0.0

LDFLAGS = -X "main.BuildTS=$(shell date -u '+%Y-%m-%d %I:%M:%S')"
LDFLAGS += -X "main.GitHash=$(shell git rev-parse HEAD)"
LDFLAGS += -X "main.GitBranch=$(shell git rev-parse --abbrev-ref HEAD)"
LDFLAGS += -X "main.Version=${VERSION}"

ifeq ($(gorace), 1)
	BUILD_FLAGS=-race
endif

build:
	go build -ldflags '$(LDFLAGS)' $(BUILD_FLAGS) main.go

lint:
	golangci-lint run ./...

// Version information.
var (
	BuildTS   = "None"
	GitHash   = "None"
	GitBranch = "None"
	Version   = "None"
)

func GetVersion() string {
	if GitHash != "" {
		h := GitHash
		if len(h) > 7 {
			h = h[:7]
		}
		return fmt.Sprintf("%s-%s", Version, h)
	}
	return Version
}

// Printer print build version
func Printer() {
	fmt.Println("Version:          ", GetVersion())
	fmt.Println("Git Branch:       ", GitBranch)
	fmt.Println("Git Commit:       ", GitHash)
	fmt.Println("Build Time (UTC): ", BuildTS)
}

var (
	PrintVersion = flag.Bool("version", false, "print the version of this build")
)

func main(){
	flag.Parse()
	if *PrintVersion {
		Printer()
		os.Exit(0)
	}
}

> make build
> ./main -version

Version:           v1.0.0-ed89d91
Git Branch:        master
Git Commit:        ed89d91d03834fe85b1ca7f74f0cca305b8e516a
Build Time (UTC):  2022-11-30 04:52:45

» export gorace=1
» make build
go build -ldflags '-X "main.BuildTS=2022-12-03 05:48:59" -X "main.GitHash=e73f1126031f56178ca86deda7fceb0a71b5314e" -X "main.GitBranch=master" -X "main.Version=v1.0.0"'  main.go