moira

1
package main
2

3
import (
4
	"context"
5
	"flag"
6
	"fmt"
7
	"math/rand"
8
	"net"
9
	"net/http"
10
	"os"
11
	"os/signal"
12
	"syscall"
13
	"time"
14

15
	"go.avito.ru/DO/moira"
16
	"go.avito.ru/DO/moira/api/handler"
17
	"go.avito.ru/DO/moira/cmd"
18
	"go.avito.ru/DO/moira/database/neo4j"
19
	"go.avito.ru/DO/moira/database/redis"
20
	"go.avito.ru/DO/moira/logging"
21
	"go.avito.ru/DO/moira/metrics"
22
	"go.avito.ru/DO/moira/panicwrap"
23
	"go.avito.ru/DO/moira/sentry"
24
)
25

26
const (
27
	serviceName = "api"
28
)
29

30
var (
31
	logger                 moira.Logger
32
	configFileName         = flag.String("config", "/etc/moira/api.yml", "Path to configuration file")
33
	printVersion           = flag.Bool("version", false, "Print version and exit")
34
	printDefaultConfigFlag = flag.Bool("default-config", false, "Print default config and exit")
35
)
36

37
// Moira api bin version
38
var (
39
	MoiraVersion = "unknown"
40
	GitCommit    = "unknown"
41
	GoVersion    = "unknown"
42
)
43

44
func main() {
45
	rand.Seed(time.Now().UnixNano())
46

47
	flag.Parse()
48
	if *printVersion {
49
		fmt.Println("Moira Api")
50
		fmt.Println("Version:", MoiraVersion)
51
		fmt.Println("Git Commit:", GitCommit)
52
		fmt.Println("Go Version:", GoVersion)
53
		os.Exit(0)
54
	}
55

56
	config := getDefault()
57
	if *printDefaultConfigFlag {
58
		cmd.PrintConfig(config)
59
		os.Exit(0)
60
	}
61

62
	err := cmd.ReadConfig(*configFileName, &config)
63
	if err != nil {
64
		_, _ = fmt.Fprintf(os.Stderr, "Can not read settings: %s\n", err.Error())
65
		os.Exit(1)
66
	}
67

68
	apiConfig := config.API.getSettings()
69
	apiConfig.Netbox = config.Netbox.GetSettings()
70

71
	if err = metrics.Init(config.Statsd.GetSettings(), apiConfig.LimitMetrics); err != nil {
72
		_, _ = fmt.Fprintf(os.Stderr, "Can not configure metrics: %v\n", err)
73
		os.Exit(1)
74
	}
75

76
	if err = logging.Init(logging.ComponentApi, config.Rsyslog.GetSettings(), apiConfig.LimitLogger); err != nil {
77
		_, _ = fmt.Fprintf(os.Stderr, "Can not configure log: %v\n", err)
78
		os.Exit(1)
79
	}
80

81
	if err = sentry.Init(apiConfig.Sentry, serviceName); err != nil {
82
		_, _ = fmt.Fprintf(os.Stderr, "Can not configure sentry: %v\n", err)
83
		os.Exit(1)
84
	}
85
	panicwrap.Init(serviceName)
86

87
	logger = logging.GetLogger("")
88
	defer logger.InfoF("Moira API Stopped. Version: %s", MoiraVersion)
89

90
	configFileContent, err := moira.GetFileContent(config.API.WebConfigPath)
91
	if err != nil {
92
		logger.WarnF("Failed to read web config file by path '%s', method 'api/config' will be return 404, error: %s'", config.API.WebConfigPath, err.Error())
93
	}
94

95
	if config.Pprof.Listen != "" {
96
		logger.InfoF("Starting pprof server at: [%s]", config.Pprof.Listen)
97
		cmd.StartProfiling(logger, config.Pprof)
98
	}
99

100
	if config.Liveness.Listen != "" {
101
		logger.InfoF("Starting liveness server at: [%s]", config.Liveness.Listen)
102
		cmd.StartLiveness(logger, config.Liveness)
103
	}
104

105
	databaseSettings := config.Redis.GetSettings()
106
	database := redis.NewDatabase(logger, databaseSettings)
107

108
	neo4jDb, err := neo4j.NewDatabase(logger, config.Neo4j)
109
	if err != nil {
110
		logger.FatalF("Can not configure Neo4j: %s\n", err.Error())
111
	}
112

113
	listener, err := net.Listen("tcp", apiConfig.Listen)
114
	if err != nil {
115
		logger.Fatal(err.Error())
116
	}
117

118
	logger.InfoF("Start listening by address: [%s]", apiConfig.Listen)
119

120
	httpHandler := handler.NewHandler(database, neo4jDb, logger, apiConfig, []byte(configFileContent), MoiraVersion)
121
	server := &http.Server{
122
		Handler: httpHandler,
123
	}
124

125
	go func() {
126
		_ = server.Serve(listener)
127
	}()
128
	defer Stop(logger, server)
129

130
	logger.InfoF("Moira Api Started (version: %s)", MoiraVersion)
131
	ch := make(chan os.Signal, 1)
132
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
133
	logger.Info(fmt.Sprint(<-ch))
134
	logger.Info("Moira API shutting down.")
135
}
136

137
// Stop Moira API HTTP server
138
func Stop(logger moira.Logger, server *http.Server) {
139
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
140
	defer cancel()
141
	if err := server.Shutdown(ctx); err != nil {
142
		logger.ErrorF("Can't stop Moira API correctly: %v", err)
143
	}
144
	logger.InfoF("Moira API Stopped. Version: %s", MoiraVersion)
145
}
146