mirror of
https://github.com/fnproject/fn.git
synced 2022-10-28 21:29:17 +03:00
e637f9736e
now we can run multiple lbs in the same 'cluster' and they will all point to the same nodes. all lb nodes are not guaranteed to have the same set of functions nodes to route to at any point in time since each lb node will perform its own health checks independently, but they will all be backed by the same list from the db to health check at least. in cases where there will be more than a few lbs we can rethink this strategy, we mostly need to back the lbs with a db so that they persist nodes and remain fault tolerant in that sense. the strategy of independent health checks is useful to reduce thrashing the db during network partitions between lb and fn pairs. it would be nice to have gossip health checking to reduce network traffic, but this works too, and we'll need to seed any gossip protocol with a list from a db anyway. db_url is the same format as what functions takes. i don't have env vars set up for fnlb right now (low hanging fruit), the flag is `-db`, it defaults to in memory sqlite3 so nodes will be forgotten between reboots. used the sqlx stuff, decided not to put the lb stuff in the datastore stuff as this was easy enough to just add here to get the sugar, and avoid bloating the datastore interface. the tables won't collide, so can just use same pg/mysql as what the fn servers are running in prod even, db load is low from lb (1 call every 1s per lb). i need to add some tests, touch testing worked as expected.
92 lines
2.3 KiB
Go
92 lines
2.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"flag"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
"gitlab-odx.oracle.com/odx/functions/fnlb/lb"
|
|
)
|
|
|
|
const VERSION = "0.0.1"
|
|
|
|
func main() {
|
|
// XXX (reed): normalize
|
|
fnodes := flag.String("nodes", "", "comma separated list of functions nodes")
|
|
|
|
var conf lb.Config
|
|
flag.StringVar(&conf.DBurl, "db", "sqlite3://:memory:", "backend to store nodes, default to in memory")
|
|
flag.StringVar(&conf.Listen, "listen", ":8081", "port to run on")
|
|
flag.IntVar(&conf.HealthcheckInterval, "hc-interval", 3, "how often to check f(x) nodes, in seconds")
|
|
flag.StringVar(&conf.HealthcheckEndpoint, "hc-path", "/version", "endpoint to determine node health")
|
|
flag.IntVar(&conf.HealthcheckUnhealthy, "hc-unhealthy", 2, "threshold of failed checks to declare node unhealthy")
|
|
flag.IntVar(&conf.HealthcheckTimeout, "hc-timeout", 5, "timeout of healthcheck endpoint, in seconds")
|
|
flag.Parse()
|
|
|
|
if len(*fnodes) > 0 {
|
|
// starting w/o nodes is fine too
|
|
conf.Nodes = strings.Split(*fnodes, ",")
|
|
}
|
|
|
|
conf.Transport = &http.Transport{
|
|
Proxy: http.ProxyFromEnvironment,
|
|
Dial: (&net.Dialer{
|
|
Timeout: 10 * time.Second,
|
|
KeepAlive: 120 * time.Second,
|
|
}).Dial,
|
|
MaxIdleConnsPerHost: 512,
|
|
TLSHandshakeTimeout: 10 * time.Second,
|
|
TLSClientConfig: &tls.Config{
|
|
ClientSessionCache: tls.NewLRUClientSessionCache(4096),
|
|
},
|
|
}
|
|
|
|
g, err := lb.NewAllGrouper(conf)
|
|
if err != nil {
|
|
logrus.WithError(err).Fatal("error setting up grouper")
|
|
}
|
|
|
|
r := lb.NewConsistentRouter(conf)
|
|
k := func(r *http.Request) (string, error) {
|
|
return r.URL.Path, nil
|
|
}
|
|
|
|
h := lb.NewProxy(k, g, r, conf)
|
|
h = g.Wrap(h) // add/del/list endpoints
|
|
h = r.Wrap(h) // stats / dash endpoint
|
|
|
|
err = serve(conf.Listen, h)
|
|
if err != nil {
|
|
logrus.WithError(err).Fatal("server error")
|
|
}
|
|
}
|
|
|
|
func serve(addr string, handler http.Handler) error {
|
|
server := &http.Server{Addr: addr, Handler: handler}
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(1)
|
|
defer wg.Wait()
|
|
|
|
ch := make(chan os.Signal, 1)
|
|
signal.Notify(ch, syscall.SIGQUIT, syscall.SIGINT)
|
|
go func() {
|
|
defer wg.Done()
|
|
for sig := range ch {
|
|
logrus.WithFields(logrus.Fields{"signal": sig}).Info("received signal")
|
|
server.Shutdown(context.Background()) // safe shutdown
|
|
return
|
|
}
|
|
}()
|
|
return server.ListenAndServe()
|
|
}
|