func (t *traefik) UpsertFrontend(fr loadbalancer.Frontend) error {
f, ok := fr.(*frontend)
if !ok {
return fmt.Errorf("Not of expected type: %v", fr)
}
pre := path.Join(t.prefix, "frontends", fr.GetID())
if er := t.Set(path.Join(pre, "backend"), f.Backend); er != nil {
return fmt.Errorf("Upsert %v failed: %v", fr, er)
}
if f.PassHostHeader {
if er := t.Set(path.Join(pre, phh), "true"); er != nil {
logger.Warnf("[%v] Upsert %s error: %v", fr.GetID(), phh, er)
}
}
for id, rt := range f.Routes {
logger.Debugf("[%v] Adding Route(%s=%q)", fr.GetID(), rt.Rule, rt.Value)
ruleK := path.Join(pre, "routes", id, "rule")
valk := path.Join(pre, "routes", id, "value")
if er := t.Set(ruleK, rt.Rule); er != nil {
logger.Warnf("[%v] Upsert rule error: %v", fr.GetID(), er)
}
if er := t.Set(valk, rt.Value); er != nil {
logger.Warnf("[%v] Upsert value error: %v", fr.GetID(), er)
}
}
return nil
}
func (t *traefik) UpsertBackend(ba loadbalancer.Backend) error {
b, ok := ba.(*backend)
if !ok {
return fmt.Errorf("Not of expected type: %v", ba)
}
pre := path.Join(t.prefix, "backends", ba.GetID())
if b.CircuitBreaker != nil && b.CircuitBreaker.Expression != "" {
if er := t.Set(path.Join(pre, cb), b.CircuitBreaker.Expression); er != nil {
logger.Warnf("[%v] Upsert %s error: %v", ba.GetID(), cb, er)
}
}
if b.LoadBalancer != nil && b.LoadBalancer.Method != "" {
if er := t.Set(path.Join(pre, lb), b.LoadBalancer.Method); er != nil {
logger.Warnf("[%v] Upsert %s error: %v", ba.GetID(), lb, er)
}
}
for id, srv := range b.Servers {
logger.Debugf("[%v] Upserting Server(%v)", ba.GetID(), srv.URL)
urlK := path.Join(pre, "servers", id, "url")
weightK := path.Join(pre, "servers", id, "weight")
if er := t.Set(urlK, srv.URL); er != nil {
logger.Warnf("[%v] Upsert error: %v", ba.GetID(), er)
}
weight := strconv.Itoa(srv.Weight)
if er := t.Set(weightK, weight); er != nil {
logger.Warnf("[%v] Upsert error: %v", ba.GetID(), er)
}
}
return nil
}
func (v *vulcan) NewMiddlewares(rsc *kubernetes.Resource) ([]loadbalancer.Middleware, error) {
mids := make([]loadbalancer.Middleware, 0, 1)
for key, def := range DefaultMiddleware {
if val, ok := rsc.GetAnnotation(key); ok && len(val) > 0 {
switch key {
case RedirectSSLID:
if b, er := strconv.ParseBool(val); er != nil || !b {
continue
}
case TraceID:
re := regexp.MustCompile(`\s+`)
list, er := json.Marshal(strings.Split(re.ReplaceAllString(val, ""), ","))
if er != nil || string(list) == "" {
logger.Warnf("Unable to json-ify trace headers: %v", er)
list = []byte("[]")
}
def = fmt.Sprintf(def, string(list), string(list))
case AuthID:
bits := strings.SplitN(val, ":", 2)
switch len(bits) {
case 1:
def = fmt.Sprintf(def, bits[0], "")
case 2:
def = fmt.Sprintf(def, bits[0], bits[1])
default:
logger.Errorf("Failed to parse provided basic auth, using default (admin:admin)")
def = fmt.Sprintf(def, "admin", "admin")
}
case MaintenanceID:
def = fmt.Sprintf(def, val)
}
m, er := engine.MiddlewareFromJSON([]byte(def), v.Registry.GetSpec, key)
if er != nil {
logger.Warnf("Failed to parse Middleware %s: %v", key, er)
logger.Debugf("%q", def)
continue
}
mids = append(mids, newMiddleware(m))
}
}
rg := regexp.MustCompile(CustomMiddlewareKeyPattern)
matches, _ := rsc.GetAnnotations(CustomMiddlewareKeyPattern)
for key, val := range matches {
if match := rg.FindStringSubmatch(key); match != nil {
id := match[1]
m, er := engine.MiddlewareFromJSON([]byte(val), v.Registry.GetSpec, id)
if er != nil {
logger.Warnf("Failed to parse Middleware %s: %v", id, er)
continue
}
mids = append(mids, newMiddleware(m))
}
}
return mids, nil
}
func (v *vulcan) NewBackend(rsc *kubernetes.Resource) (loadbalancer.Backend, error) {
s := engine.HTTPBackendSettings{
Timeouts: engine.HTTPBackendTimeouts{},
KeepAlive: engine.HTTPBackendKeepAlive{},
}
if val, ok := rsc.GetAnnotation(DailTimeoutKey); ok {
s.Timeouts.Dial = val
}
if val, ok := rsc.GetAnnotation(ReadTimeoutKey); ok {
s.Timeouts.Read = val
}
if val, ok := rsc.GetAnnotation(MaxIdleConnsKey); ok {
if i, er := strconv.Atoi(val); er == nil {
s.KeepAlive.MaxIdleConnsPerHost = i
}
}
if val, ok := rsc.GetAnnotation(loadbalancer.BackendSettingsKey); ok {
if er := json.Unmarshal([]byte(val), &s); er != nil {
logger.Warnf("Failed to parse settings for frontend %q: %v", rsc.ID, er)
}
}
b, er := engine.NewHTTPBackend(rsc.ID(), s)
if er != nil {
return nil, er
}
if rsc.IsWebsocket() {
b.Type = ws
}
return newBackend(b), nil
}
func (v *vulcan) NewFrontend(rsc *kubernetes.Resource) (loadbalancer.Frontend, error) {
s := engine.HTTPFrontendSettings{}
if val, ok := rsc.GetAnnotation(loadbalancer.PassHostHeaderKey); ok {
b, _ := strconv.ParseBool(val)
s.PassHostHeader = b
}
if val, ok := rsc.GetAnnotation(loadbalancer.TrustForwardHeadersKey); ok {
b, _ := strconv.ParseBool(val)
s.TrustForwardHeader = b
}
if val, ok := rsc.GetAnnotation(loadbalancer.FailoverExpressionKey); ok {
s.FailoverPredicate = val
}
if val, ok := rsc.GetAnnotation(loadbalancer.FrontendSettingsKey); ok {
if er := json.Unmarshal([]byte(val), &s); er != nil {
logger.Warnf("Failed to parse settings for frontend %q: %v", rsc.ID, er)
}
}
f, er := engine.NewHTTPFrontend(vroute.NewMux(), rsc.ID(), rsc.ID(), NewRoute(rsc.Route).String(), s)
if er != nil {
return nil, er
}
return newFrontend(f), nil
}
func (s *torrentStatus) setFailures() {
switch {
case s.Error != 0:
logger.Warnf("[Torrent %d: %q] Error: %s", s.ID, s.Name, s.ErrorString)
s.failures++
case s.IsFinished:
logger.Infof("[Torrent %d: %q] Finished", s.ID, s.Name)
s.failures = 3
}
}
func LogCallback(callback string, obj interface{}) {
format := "%s %s"
switch t := obj.(type) {
default:
logger.Warnf(format, callback, "<unknown>")
case *extensions.Ingress:
logger.Infof(format, callback, Ingress(*t))
case *api.Service:
logger.Infof(format, callback, Service(*t))
case *api.Endpoints:
logger.Infof(format, callback, Endpoints(*t))
}
}
func createObjectCache(e *Engine, selector kubernetes.Selector, resync time.Duration) {
var (
uc = e.GetUnversionedClient()
ec = e.GetExtensionsClient()
)
logger.Infof("Creating kubernetes object cache")
service, er := kubernetes.CreateStore(kubernetes.ServicesKind, uc, selector, resync, e.Context)
if er != nil {
logger.Warnf("Failed to create Service cache")
}
endpoints, er := kubernetes.CreateStore(kubernetes.EndpointsKind, uc, selector, resync, e.Context)
if er != nil {
logger.Warnf("Failed to create Endpoints cache")
}
ingress, er := kubernetes.CreateStore(kubernetes.IngressesKind, ec, selector, resync, e.Context)
if er != nil {
logger.Warnf("Failed to create Ingress cache")
}
e.SetIngressStore(ingress)
e.SetServiceStore(service)
e.SetEndpointsStore(endpoints)
}
func (v *vulcan) UpsertFrontend(fr loadbalancer.Frontend) error {
f, ok := fr.(*frontend)
if !ok {
return loadbalancer.ErrUnexpectedFrontendType
}
if er := v.Client.UpsertFrontend(f.Frontend, 0); er != nil {
return er
}
for _, mid := range f.middlewares {
if er := v.UpsertMiddleware(f.GetKey(), mid.Middleware, 0); er != nil {
logger.Warnf("Failed to upsert Middleware %s for frontend %s: %v", mid.GetID(), f.GetID(), er)
}
}
return nil
}
func (r *RawClient) CheckPort() bool {
var (
open bool
resp = new(response)
req, _ = newRequest("port-test")
body, _ = json.Marshal(req)
out, er = r.Post(string(body))
)
if er != nil {
logger.Warnf("Failed to check port: %v", er)
return false
}
if er := json.Unmarshal(out, resp); er != nil {
logger.Warnf("Failed to check port: %v", er)
return false
}
arg := resp.Args["port-is-open"]
if er := json.Unmarshal(*arg, &open); er != nil {
logger.Warnf("Failed to check port: %v", er)
return false
}
return open
}
func (e *Engine) Commit(fn UpsertFunc) error {
e.Reset()
for {
select {
case <-e.Done():
return nil
default:
duration := e.NextBackOff()
if duration == backoff.Stop {
return errors.New("Timed out trying to Commit changes to loadbalancer")
}
er := fn()
if er == nil {
return er
}
logger.Warnf("Commit failed, retry in %v: %v", duration, er)
time.Sleep(duration)
}
}
}