forked from cloudfoundry/auctioneer
/
main.go
148 lines (120 loc) · 3.55 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
138
139
140
141
142
143
144
145
146
147
148
package main
import (
"flag"
"os"
"strings"
"time"
"github.com/cloudfoundry-incubator/cf-lager"
Bbs "github.com/cloudfoundry-incubator/runtime-schema/bbs"
"github.com/pivotal-golang/lager"
"github.com/cloudfoundry-incubator/auction/auctionrunner"
"github.com/cloudfoundry-incubator/auction/communication/nats/auction_nats_client"
"github.com/cloudfoundry-incubator/auctioneer/auctioneer"
"github.com/cloudfoundry/gunk/timeprovider"
"github.com/cloudfoundry/storeadapter/etcdstoreadapter"
"github.com/cloudfoundry/storeadapter/workerpool"
"github.com/cloudfoundry/yagnats"
"github.com/tedsuo/ifrit"
"github.com/tedsuo/ifrit/sigmon"
)
var etcdCluster = flag.String(
"etcdCluster",
"http://127.0.0.1:4001",
"comma-separated list of etcd addresses (http://ip:port)",
)
var natsAddresses = flag.String(
"natsAddresses",
"127.0.0.1:4222",
"comma-separated list of NATS addresses (ip:port)",
)
var natsUsername = flag.String(
"natsUsername",
"nats",
"Username to connect to nats",
)
var natsPassword = flag.String(
"natsPassword",
"nats",
"Password for nats user",
)
var maxConcurrent = flag.Int(
"maxConcurrent",
20,
"Maximum number of concurrent auctions",
)
var maxRounds = flag.Int(
"maxRounds",
auctionrunner.DefaultStartAuctionRules.MaxRounds,
"Maximum number of rounds to run before declaring failure",
)
var auctionNATSTimeout = flag.Duration(
"natsAuctionTimeout",
time.Second,
"How long the auction will wait to hear back from a request/response nats message",
)
var auctionRunTimeout = flag.Duration(
"runAuctionTimeout",
10*time.Second,
"How long the auction will wait to hear that the chosen winner has succesfully started the app",
)
var lockInterval = flag.Duration(
"lockInterval",
30*time.Second,
"Interval at which to maintain the auctioneer lock",
)
func main() {
flag.Parse()
logger := cf_lager.New("auctioneer")
natsClient := initializeNatsClient(logger)
bbs := initializeBbs(logger)
auctioneer := initializeAuctioneer(bbs, natsClient, logger)
process := ifrit.Envoke(auctioneer)
logger.Info("auctioneer.started")
monitor := ifrit.Envoke(sigmon.New(process))
err := <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("auctioneer.exited")
}
func initializeAuctioneer(bbs Bbs.AuctioneerBBS, natsClient yagnats.NATSClient, logger lager.Logger) *auctioneer.Auctioneer {
client, err := auction_nats_client.New(natsClient, *auctionNATSTimeout, *auctionRunTimeout, logger)
if err != nil {
logger.Fatal("failed-to-create-auctioneer-nats-client", err)
}
runner := auctionrunner.New(client)
return auctioneer.New(bbs, runner, *maxConcurrent, *maxRounds, *lockInterval, logger)
}
func initializeNatsClient(logger lager.Logger) yagnats.NATSClient {
natsClient := yagnats.NewClient()
natsMembers := []yagnats.ConnectionProvider{}
for _, addr := range strings.Split(*natsAddresses, ",") {
natsMembers = append(
natsMembers,
&yagnats.ConnectionInfo{
Addr: addr,
Username: *natsUsername,
Password: *natsPassword,
},
)
}
err := natsClient.Connect(&yagnats.ConnectionCluster{
Members: natsMembers,
})
if err != nil {
logger.Fatal("failed-to-connect-to-nats", err)
}
return natsClient
}
func initializeBbs(logger lager.Logger) Bbs.AuctioneerBBS {
etcdAdapter := etcdstoreadapter.NewETCDStoreAdapter(
strings.Split(*etcdCluster, ","),
workerpool.NewWorkerPool(10),
)
err := etcdAdapter.Connect()
if err != nil {
logger.Fatal("failed-to-connect-to-etcd", err)
}
return Bbs.NewAuctioneerBBS(etcdAdapter, timeprovider.NewTimeProvider(), logger)
}