forked from vladaionescu/leveros
/
main.go
137 lines (116 loc) · 3.79 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
132
133
134
135
136
137
// Package main runs a Lever OS host. A Lever OS host is the main process in
// a Lever deployment. It manages traffic through the Lever network and manages
// Lever instances.
package main
import (
"net"
"github.com/leveros/leveros/apiserver"
"github.com/leveros/leveros/cmd"
"github.com/leveros/leveros/config"
"github.com/leveros/leveros/devlogger"
"github.com/leveros/leveros/dockerutil"
"github.com/leveros/leveros/fleettracker"
"github.com/leveros/leveros/host"
"github.com/leveros/leveros/hostman"
"github.com/leveros/leveros/leverutil"
"github.com/leveros/leveros/scale"
"github.com/leveros/leveros/store"
"google.golang.org/grpc"
)
// PackageName is the name of this package.
const PackageName = cmd.PackageName + ".leveroshost"
var (
// Version is the version of Lever OS. This variable is set at build time.
Version string
// GitHash is the git hash of Lever OS. This variable is set at build time.
GitHash string
)
var logger = leverutil.GetLogger(PackageName, "main")
var (
// InternalGRPCListenPortFlag is the port to listen to for internal GRPC
// connections.
InternalGRPCListenPortFlag = config.DeclareString(
PackageName, "internalGRPCListenPort", "3501")
// ExternalIPFlag is the host's external IP address.
ExternalIPFlag = config.DeclareString(
PackageName, "externalIP", "127.0.0.1")
)
func main() {
config.Initialize()
leverutil.UpdateLoggingSettings()
logger.WithFields(
"version", Version,
"gitHash", GitHash,
).Info("Starting up...")
_, err := devlogger.NewDevLogger(ExternalIPFlag.Get())
if err != nil {
logger.WithFields("err", err).Fatal("Cannot start devlogger")
}
// Docker.
dockerLocal := dockerutil.NewDockerLocal()
dockerSwarm := dockerutil.NewDockerSwarm()
// Own regional IP.
ownIP, err := dockerutil.GetOwnEnvIPv4(
dockerLocal, hostman.RegionalNetworkFlag.Get())
if err != nil {
logger.WithFields("err", err).Fatal("Error getting own regional IPv4")
}
// Own GRPC address.
grpcAddr := ownIP + ":" + InternalGRPCListenPortFlag.Get()
// Start internal GRPC server.
listener, err := net.Listen("tcp", grpcAddr)
if err != nil {
logger.WithFields(
"err", err,
"listenAddr", grpcAddr,
).Fatal("Could not start listening")
}
grpcServer := grpc.NewServer()
// GRPC client pool.
grpcPool, err := scale.NewGRPCPool()
if err != nil {
logger.WithFields("err", err).Fatal("Cannot create GRPC pool")
}
// Start finder.
as, err := store.NewAerospike()
if err != nil {
logger.WithFields("err", err).Fatal("Cannot get aerospike client")
}
finder := host.NewFinder(dockerSwarm, as)
// Start host manager.
proxyInAddr := ownIP + ":" + host.EnvInListenPortFlag.Get()
manager, err := hostman.NewManager(
grpcServer, grpcPool, dockerLocal, grpcAddr, proxyInAddr)
if err != nil {
logger.WithFields("err", err).Fatal("Cannot create host manager")
}
// Start proxy.
_, err = host.NewLeverProxy(manager, finder, ownIP, grpcPool)
if err != nil {
logger.WithFields("err", err).Fatal("Cannot create Lever proxy")
}
// Start fleettracker.
_, err = fleettracker.NewFleetTracker(
grpcServer, grpcPool, dockerSwarm, grpcAddr)
if err != nil {
logger.WithFields("err", err).Fatal("Error starting fleettracker")
}
// Start API server.
_, err = apiserver.NewServer()
if err != nil {
logger.WithFields("err", err).Fatal("Error starting API server")
}
logger.Info("\n" +
" _ ___ ___ \n" +
" | | _____ _____ _ _ / _ \\/ __|\n" +
" | |__/ -_) V / -_) '_| | (_) \\__ \\\n" +
" |____\\___|\\_/\\___|_| \\___/|___/\n" +
" v" + Version + "\n" +
" Ready to serve\n")
// GRPC enter loop.
err = grpcServer.Serve(listener)
if err != nil {
logger.WithFields("err", err).Fatal("Error in internal GRPC server")
}
// TODO: Ideally we should trap signals and shut down properly.
}