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) } } }