From 2c5ee0ea872cb5534a7b6094899e690501513399 Mon Sep 17 00:00:00 2001 From: Trekkie Coder Date: Tue, 11 Jul 2023 01:32:56 +0900 Subject: [PATCH 1/3] Liveness check type on a per-rule basis (#350) --- api/models/loadbalance_entry.go | 6 +++ api/restapi/embedded_spec.go | 27 +++++++++++ api/restapi/handler/loadbalancer.go | 4 ++ api/swagger.yml | 7 +++ common/common.go | 4 ++ loxinet/rules.go | 75 ++++++++++++++++++++++++----- 6 files changed, 110 insertions(+), 13 deletions(-) diff --git a/api/models/loadbalance_entry.go b/api/models/loadbalance_entry.go index 28b26dca1..66314f1a3 100644 --- a/api/models/loadbalance_entry.go +++ b/api/models/loadbalance_entry.go @@ -330,6 +330,12 @@ type LoadbalanceEntryServiceArguments struct { // port number for the access Port int64 `json:"port,omitempty"` + // probe port if probetype is tcp/udp/sctp + Probeport uint16 `json:"probeport,omitempty"` + + // probe type for any end-point of this entry + Probetype string `json:"probetype,omitempty"` + // value for access protocol Protocol string `json:"protocol,omitempty"` diff --git a/api/restapi/embedded_spec.go b/api/restapi/embedded_spec.go index f28639c64..ad3b53e88 100644 --- a/api/restapi/embedded_spec.go +++ b/api/restapi/embedded_spec.go @@ -3505,6 +3505,15 @@ func init() { "description": "port number for the access", "type": "integer" }, + "probeport": { + "description": "probe port if probetype is tcp/udp/sctp", + "type": "integer", + "format": "uint16" + }, + "probetype": { + "description": "probe type for any end-point of this entry", + "type": "string" + }, "protocol": { "description": "value for access protocol", "type": "string" @@ -7602,6 +7611,15 @@ func init() { "description": "port number for the access", "type": "integer" }, + "probeport": { + "description": "probe port if probetype is tcp/udp/sctp", + "type": "integer", + "format": "uint16" + }, + "probetype": { + "description": "probe type for any end-point of this entry", + "type": "string" + }, "protocol": { "description": "value for access protocol", "type": "string" @@ -7680,6 +7698,15 @@ func init() { "description": "port number for the access", "type": "integer" }, + "probeport": { + "description": "probe port if probetype is tcp/udp/sctp", + "type": "integer", + "format": "uint16" + }, + "probetype": { + "description": "probe type for any end-point of this entry", + "type": "string" + }, "protocol": { "description": "value for access protocol", "type": "string" diff --git a/api/restapi/handler/loadbalancer.go b/api/restapi/handler/loadbalancer.go index 758a26c23..01bbe7774 100644 --- a/api/restapi/handler/loadbalancer.go +++ b/api/restapi/handler/loadbalancer.go @@ -38,6 +38,8 @@ func ConfigPostLoadbalancer(params operations.PostConfigLoadbalancerParams) midd lbRules.Serv.Mode = cmn.LBMode(params.Attr.ServiceArguments.Mode) lbRules.Serv.InactiveTimeout = uint32(params.Attr.ServiceArguments.InactiveTimeOut) lbRules.Serv.Managed = params.Attr.ServiceArguments.Managed + lbRules.Serv.ProbeType = params.Attr.ServiceArguments.Probetype + lbRules.Serv.ProbePort = params.Attr.ServiceArguments.Probeport if lbRules.Serv.Proto == "sctp" { for _, data := range params.Attr.SecondaryIPs { @@ -119,6 +121,8 @@ func ConfigGetLoadbalancer(params operations.GetConfigLoadbalancerAllParams) mid tmpSvc.InactiveTimeOut = int32(lb.Serv.InactiveTimeout) tmpSvc.Monitor = lb.Serv.Monitor tmpSvc.Managed = lb.Serv.Managed + tmpSvc.Probetype = lb.Serv.ProbeType + tmpSvc.Probeport = lb.Serv.ProbePort tmpLB.ServiceArguments = &tmpSvc diff --git a/api/swagger.yml b/api/swagger.yml index d427e569e..5e754a1a7 100644 --- a/api/swagger.yml +++ b/api/swagger.yml @@ -2166,6 +2166,13 @@ definitions: monitor: type: boolean description: value for monitoring enabled or not + probetype: + type: string + description: probe type for any end-point of this entry + probeport: + type: integer + format: uint16 + description: probe port if probetype is tcp/udp/sctp managed: type: boolean description: externally managed rule or not diff --git a/common/common.go b/common/common.go index edea0201e..f7ba1b15a 100644 --- a/common/common.go +++ b/common/common.go @@ -500,6 +500,10 @@ type LbServiceArg struct { InactiveTimeout uint32 `json:"inactiveTimeout"` // Managed - This rule is managed by external entity e.g k8s Managed bool `json:"managed"` + // ProbeType - Liveness check type for this rule : ping, tcp, udp, sctp, none + ProbeType string `json:"probetype"` + // ProbePort - Liveness check port number. Only valid for tcp, udp, sctp + ProbePort uint16 `json:"probeport"` } // LbEndPointArg - Information related to load-balancer end-point diff --git a/loxinet/rules.go b/loxinet/rules.go index 32c1d7fa8..fdb11d1c9 100644 --- a/loxinet/rules.go +++ b/loxinet/rules.go @@ -250,6 +250,8 @@ type ruleEnt struct { tuples ruleTuples ci string actChk bool + prbType string + prbPort uint16 managed bool bgp bool sT time.Time @@ -722,6 +724,8 @@ func (R *RuleH) GetNatLbRule() ([]cmn.LbRuleMod, error) { ret.Serv.Bgp = data.bgp ret.Serv.BlockNum = data.tuples.pref ret.Serv.Managed = data.managed + ret.Serv.ProbeType = data.prbType + ret.Serv.ProbePort = data.prbPort for _, sip := range data.secIP { ret.SecIPs = append(ret.SecIPs, cmn.LbSecIpArg{SecIP: sip.sIP.String()}) @@ -778,19 +782,26 @@ func (R *RuleH) modNatEpHost(r *ruleEnt, endpoints []ruleNatEp, doAddOp bool, li hopts.inActTryThr = DflLbaInactiveTries hopts.probeDuration = DflHostProbeTimeout for _, nep := range endpoints { - if r.tuples.l4Prot.val == 6 { - hopts.probeType = HostProbeConnectTcp - hopts.probePort = nep.xPort - } else if r.tuples.l4Prot.val == 17 { - hopts.probeType = HostProbeConnectUdp - hopts.probePort = nep.xPort - } else if r.tuples.l4Prot.val == 1 { - hopts.probeType = HostProbePing - } else if r.tuples.l4Prot.val == 132 { - hopts.probeType = HostProbeConnectSctp - hopts.probePort = nep.xPort + if r.prbType == "" { + if r.tuples.l4Prot.val == 6 { + hopts.probeType = HostProbeConnectTcp + hopts.probePort = nep.xPort + } else if r.tuples.l4Prot.val == 17 { + hopts.probeType = HostProbeConnectUdp + hopts.probePort = nep.xPort + } else if r.tuples.l4Prot.val == 1 { + hopts.probeType = HostProbePing + } else if r.tuples.l4Prot.val == 132 { + hopts.probeType = HostProbeConnectSctp + hopts.probePort = nep.xPort + } else { + hopts.probeType = HostProbePing + } } else { - hopts.probeType = HostProbePing + // If probetype is specified as a part of rule, + // override per end-point liveness settings + hopts.probeType = r.prbType + hopts.probePort = r.prbPort } if mh.pProbe == true || liveCheckEn { @@ -954,6 +965,36 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, serv.InactiveTimeout = LbDefaultInactiveTimeout } + // Validate liveness probetype and port + if serv.ProbeType != "" { + if serv.ProbeType != HostProbeConnectSctp && + serv.ProbeType != HostProbeConnectTcp && + serv.ProbeType != HostProbeConnectUdp && + serv.ProbeType != HostProbePing && + serv.ProbeType != HostProbeNone { + return RuleArgsErr, errors.New("malformed-service-ptype error") + } + + if (serv.ProbeType == HostProbeConnectSctp || + serv.ProbeType == HostProbeConnectTcp || + serv.ProbeType == HostProbeConnectUdp) && + (serv.ProbePort == 0) { + return RuleArgsErr, errors.New("malformed-service-pport error") + } + + if (serv.ProbeType == HostProbeNone || serv.ProbeType == HostProbePing) && + (serv.ProbePort != 0) { + return RuleArgsErr, errors.New("malformed-service-pport error") + } + + // Override monitor flag to true if certain conditions meet + if serv.ProbeType != HostProbeNone { + serv.Monitor = true + } + } else if serv.ProbePort != 0 { + return RuleArgsErr, errors.New("malformed-service-pport error") + } + // Currently support a maximum of MAX_NAT_EPS if len(servEndPoints) <= 0 || len(servEndPoints) > MaxNatEndPoints { return RuleEpCountErr, errors.New("endpoints-range error") @@ -1088,11 +1129,17 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, e.mark = false } + if eRule.prbType != serv.ProbeType || eRule.prbPort != serv.ProbePort { + ruleChg = true + } + if ruleChg == false { return RuleExistsErr, errors.New("lbrule-exists error") } // Update the rule + eRule.prbType = serv.ProbeType + eRule.prbPort = serv.ProbePort eRule.act.action.(*ruleNatActs).sel = natActs.sel eRule.act.action.(*ruleNatActs).endPoints = eEps eRule.act.action.(*ruleNatActs).mode = natActs.mode @@ -1119,9 +1166,11 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, } r.managed = serv.Managed r.secIP = nSecIP - // Per LB end-point health-check is supposed to be handled at CCM, + // Per LB end-point health-check is supposed to be handled at kube-loxilb/CCM, // but it certain cases like stand-alone mode, loxilb can do its own // lb end-point health monitoring + r.prbType = serv.ProbeType + r.prbPort = serv.ProbePort r.actChk = serv.Monitor r.act.action = &natActs r.ruleNum, err = R.tables[RtLB].Mark.GetCounter() From 8588d63874b001871ad5e6936424fa6430439c2f Mon Sep 17 00:00:00 2001 From: Trekkie Coder Date: Tue, 11 Jul 2023 09:52:01 +0900 Subject: [PATCH 2/3] Liveness check type on a per-rule basis (#350) --- loxinet/rules.go | 73 +++++++++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 32 deletions(-) diff --git a/loxinet/rules.go b/loxinet/rules.go index fdb11d1c9..8922a53e9 100644 --- a/loxinet/rules.go +++ b/loxinet/rules.go @@ -243,15 +243,19 @@ type ruleStat struct { packets uint64 } +type ruleProbe struct { + actChk bool + prbType string + prbPort uint16 +} + type ruleEnt struct { zone *Zone ruleNum uint64 sync DpStatusT tuples ruleTuples ci string - actChk bool - prbType string - prbPort uint16 + hChk ruleProbe managed bool bgp bool sT time.Time @@ -719,13 +723,13 @@ func (R *RuleH) GetNatLbRule() ([]cmn.LbRuleMod, error) { ret.Serv.ServPort = data.tuples.l4Dst.val ret.Serv.Sel = data.act.action.(*ruleNatActs).sel ret.Serv.Mode = data.act.action.(*ruleNatActs).mode - ret.Serv.Monitor = data.actChk + ret.Serv.Monitor = data.hChk.actChk ret.Serv.InactiveTimeout = data.iTo ret.Serv.Bgp = data.bgp ret.Serv.BlockNum = data.tuples.pref ret.Serv.Managed = data.managed - ret.Serv.ProbeType = data.prbType - ret.Serv.ProbePort = data.prbPort + ret.Serv.ProbeType = data.hChk.prbType + ret.Serv.ProbePort = data.hChk.prbPort for _, sip := range data.secIP { ret.SecIPs = append(ret.SecIPs, cmn.LbSecIpArg{SecIP: sip.sIP.String()}) @@ -779,36 +783,41 @@ func validateXlateEPWeights(servEndPoints []cmn.LbEndPointArg) (int, error) { func (R *RuleH) modNatEpHost(r *ruleEnt, endpoints []ruleNatEp, doAddOp bool, liveCheckEn bool) { var hopts epHostOpts + pType := "" + pPort := uint16(0) hopts.inActTryThr = DflLbaInactiveTries hopts.probeDuration = DflHostProbeTimeout for _, nep := range endpoints { - if r.prbType == "" { - if r.tuples.l4Prot.val == 6 { - hopts.probeType = HostProbeConnectTcp - hopts.probePort = nep.xPort - } else if r.tuples.l4Prot.val == 17 { - hopts.probeType = HostProbeConnectUdp - hopts.probePort = nep.xPort - } else if r.tuples.l4Prot.val == 1 { - hopts.probeType = HostProbePing - } else if r.tuples.l4Prot.val == 132 { - hopts.probeType = HostProbeConnectSctp - hopts.probePort = nep.xPort - } else { - hopts.probeType = HostProbePing - } + if r.tuples.l4Prot.val == 6 { + pType = HostProbeConnectTcp + pPort = nep.xPort + } else if r.tuples.l4Prot.val == 17 { + pType = HostProbeConnectUdp + pPort = nep.xPort + } else if r.tuples.l4Prot.val == 1 { + pType = HostProbePing + } else if r.tuples.l4Prot.val == 132 { + pType = HostProbeConnectSctp + pPort = nep.xPort } else { + pType = HostProbePing + } + + if r.hChk.prbType != "" { // If probetype is specified as a part of rule, // override per end-point liveness settings - hopts.probeType = r.prbType - hopts.probePort = r.prbPort + hopts.probeType = r.hChk.prbType + hopts.probePort = r.hChk.prbPort + } else { + hopts.probeType = pType + hopts.probePort = pPort } if mh.pProbe == true || liveCheckEn { hopts.probeActivated = true } - epKey := makeEPKey(nep.xIP.String(), hopts.probeType, hopts.probePort) + epKey := makeEPKey(nep.xIP.String(), pType, pPort) if doAddOp { if nep.inActive != true { @@ -1129,7 +1138,7 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, e.mark = false } - if eRule.prbType != serv.ProbeType || eRule.prbPort != serv.ProbePort { + if eRule.hChk.prbType != serv.ProbeType || eRule.hChk.prbPort != serv.ProbePort { ruleChg = true } @@ -1138,8 +1147,8 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, } // Update the rule - eRule.prbType = serv.ProbeType - eRule.prbPort = serv.ProbePort + eRule.hChk.prbType = serv.ProbeType + eRule.hChk.prbPort = serv.ProbePort eRule.act.action.(*ruleNatActs).sel = natActs.sel eRule.act.action.(*ruleNatActs).endPoints = eEps eRule.act.action.(*ruleNatActs).mode = natActs.mode @@ -1169,9 +1178,9 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, // Per LB end-point health-check is supposed to be handled at kube-loxilb/CCM, // but it certain cases like stand-alone mode, loxilb can do its own // lb end-point health monitoring - r.prbType = serv.ProbeType - r.prbPort = serv.ProbePort - r.actChk = serv.Monitor + r.hChk.prbType = serv.ProbeType + r.hChk.prbPort = serv.ProbePort + r.hChk.actChk = serv.Monitor r.act.action = &natActs r.ruleNum, err = R.tables[RtLB].Mark.GetCounter() if err != nil { @@ -1240,7 +1249,7 @@ func (R *RuleH) DeleteNatLbRule(serv cmn.LbServiceArg) (int, error) { eEps := rule.act.action.(*ruleNatActs).endPoints activatedProbe := false - if rule.act.action.(*ruleNatActs).mode == cmn.LBModeOneArm || rule.actChk { + if rule.act.action.(*ruleNatActs).mode == cmn.LBModeOneArm || rule.hChk.actChk { activatedProbe = true } R.modNatEpHost(rule, eEps, false, activatedProbe) @@ -1880,7 +1889,7 @@ func (R *RuleH) RulesSync() { rule.ruleNum, ruleKeys, ruleActs, rule.stat.packets, rule.stat.bytes) - if rule.actChk == false { + if rule.hChk.actChk == false { continue } From b23b5e7c68af549097d348cb59ed4902ff1cab99 Mon Sep 17 00:00:00 2001 From: Trekkie Coder Date: Tue, 11 Jul 2023 14:13:48 +0900 Subject: [PATCH 3/3] Liveness check type on a per-rule basis (#350) --- api/api.go | 25 +++++++++++++++++- api/models/loadbalance_entry.go | 6 +++++ api/restapi/configure_loxilb_rest_api.go | 5 +--- api/restapi/embedded_spec.go | 24 +++++++++++++++++ api/restapi/handler/loadbalancer.go | 2 ++ api/restapi/server.go | 33 +++++------------------- api/swagger.yml | 6 +++++ common/common.go | 8 ++++-- loxinet/loxinet.go | 3 +-- loxinet/rules.go | 13 +++++++++- 10 files changed, 89 insertions(+), 36 deletions(-) diff --git a/api/api.go b/api/api.go index c7a9127d1..3b519fdc4 100644 --- a/api/api.go +++ b/api/api.go @@ -32,7 +32,8 @@ import ( ) var ( - ApiReady bool + ApiReady bool + ApiShutOk chan bool ) // RegisterAPIHooks - routine to register interface for api @@ -51,6 +52,20 @@ func WaitAPIServerReady() { } } +func waitApiServerShutOk() { + for { + select { + case <-ApiShutOk: + return + } + } +} + +// ApiServerShutOk - Notifier for server to be shutdown on signals +func ApiServerShutOk() { + ApiShutOk <- true +} + // This file was generated by the swagger tool. // Make sure not to overwrite this file after you generated it because all your edits would be lost! @@ -64,6 +79,10 @@ func RunAPIServer() { } }() + if ApiShutOk == nil { + ApiShutOk = make(chan bool) + } + swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON) if err != nil { log.Fatalln(err) @@ -101,6 +120,10 @@ func RunAPIServer() { server.TLSCertificate = options.Opts.TLSCertificate server.Port = options.Opts.Port server.TLSPort = options.Opts.TLSPort + api.ServerShutdown = func() { + waitApiServerShutOk() + os.Exit(0) + } ApiReady = true if err := server.Serve(); err != nil { diff --git a/api/models/loadbalance_entry.go b/api/models/loadbalance_entry.go index 66314f1a3..5cd573bae 100644 --- a/api/models/loadbalance_entry.go +++ b/api/models/loadbalance_entry.go @@ -333,6 +333,12 @@ type LoadbalanceEntryServiceArguments struct { // probe port if probetype is tcp/udp/sctp Probeport uint16 `json:"probeport,omitempty"` + // probe request string + Probereq string `json:"probereq,omitempty"` + + // probe response string + Proberesp string `json:"proberesp,omitempty"` + // probe type for any end-point of this entry Probetype string `json:"probetype,omitempty"` diff --git a/api/restapi/configure_loxilb_rest_api.go b/api/restapi/configure_loxilb_rest_api.go index ccf0eaac0..859cd34d8 100644 --- a/api/restapi/configure_loxilb_rest_api.go +++ b/api/restapi/configure_loxilb_rest_api.go @@ -18,7 +18,6 @@ package restapi import ( "crypto/tls" "net/http" - "os" opts "github.com/loxilb-io/loxilb/options" @@ -155,9 +154,7 @@ func configureAPI(api *operations.LoxilbRestAPIAPI) http.Handler { api.PreServerShutdown = func() {} - api.ServerShutdown = func() { - os.Exit(0) - } + api.ServerShutdown = func() {} return setupGlobalMiddleware(api.Serve(setupMiddlewares)) } diff --git a/api/restapi/embedded_spec.go b/api/restapi/embedded_spec.go index ad3b53e88..18145b78d 100644 --- a/api/restapi/embedded_spec.go +++ b/api/restapi/embedded_spec.go @@ -3510,6 +3510,14 @@ func init() { "type": "integer", "format": "uint16" }, + "probereq": { + "description": "probe request string", + "type": "string" + }, + "proberesp": { + "description": "probe response string", + "type": "string" + }, "probetype": { "description": "probe type for any end-point of this entry", "type": "string" @@ -7616,6 +7624,14 @@ func init() { "type": "integer", "format": "uint16" }, + "probereq": { + "description": "probe request string", + "type": "string" + }, + "proberesp": { + "description": "probe response string", + "type": "string" + }, "probetype": { "description": "probe type for any end-point of this entry", "type": "string" @@ -7703,6 +7719,14 @@ func init() { "type": "integer", "format": "uint16" }, + "probereq": { + "description": "probe request string", + "type": "string" + }, + "proberesp": { + "description": "probe response string", + "type": "string" + }, "probetype": { "description": "probe type for any end-point of this entry", "type": "string" diff --git a/api/restapi/handler/loadbalancer.go b/api/restapi/handler/loadbalancer.go index 01bbe7774..d141de836 100644 --- a/api/restapi/handler/loadbalancer.go +++ b/api/restapi/handler/loadbalancer.go @@ -40,6 +40,8 @@ func ConfigPostLoadbalancer(params operations.PostConfigLoadbalancerParams) midd lbRules.Serv.Managed = params.Attr.ServiceArguments.Managed lbRules.Serv.ProbeType = params.Attr.ServiceArguments.Probetype lbRules.Serv.ProbePort = params.Attr.ServiceArguments.Probeport + lbRules.Serv.ProbeReq = params.Attr.ServiceArguments.Probereq + lbRules.Serv.ProbeResp = params.Attr.ServiceArguments.Proberesp if lbRules.Serv.Proto == "sctp" { for _, data := range params.Attr.SecondaryIPs { diff --git a/api/restapi/server.go b/api/restapi/server.go index 0d94c505f..5b9e1b162 100644 --- a/api/restapi/server.go +++ b/api/restapi/server.go @@ -8,11 +8,6 @@ import ( "crypto/x509" "errors" "fmt" - "github.com/go-openapi/runtime/flagext" - "github.com/go-openapi/swag" - flags "github.com/jessevdk/go-flags" - "github.com/loxilb-io/loxilb/api/restapi/operations" - "golang.org/x/net/netutil" "log" "net" "net/http" @@ -23,6 +18,13 @@ import ( "sync/atomic" "syscall" "time" + + "github.com/go-openapi/runtime/flagext" + "github.com/go-openapi/swag" + flags "github.com/jessevdk/go-flags" + "golang.org/x/net/netutil" + + "github.com/loxilb-io/loxilb/api/restapi/operations" ) const ( @@ -102,8 +104,6 @@ type Server struct { interrupt chan os.Signal } -var sigShutOk chan bool - // Logf logs message either via defined user logger or via system one if no user logger is defined. func (s *Server) Logf(f string, args ...interface{}) { if s.api != nil && s.api.Logger != nil { @@ -167,10 +167,6 @@ func (s *Server) Serve() (err error) { s.SetHandler(s.api.Serve(nil)) } - if sigShutOk == nil { - sigShutOk = make(chan bool) - } - wg := new(sync.WaitGroup) once := new(sync.Once) signalNotify(s.interrupt) @@ -491,20 +487,6 @@ func (s *Server) TLSListener() (net.Listener, error) { return s.httpsServerL, nil } -func waitServerSigShutOk() { - for { - select { - case <-sigShutOk: - return - } - } -} - -// ServerSigShutOk - Notifier for server to be shutdown on signals -func ServerSigShutOk() { - sigShutOk <- true -} - func handleInterrupt(once *sync.Once, s *Server) { once.Do(func() { for range s.interrupt { @@ -512,7 +494,6 @@ func handleInterrupt(once *sync.Once, s *Server) { s.Logf("Server already shutting down") continue } - waitServerSigShutOk() s.interrupted = true s.Logf("Shutting down... ") if err := s.Shutdown(); err != nil { diff --git a/api/swagger.yml b/api/swagger.yml index 5e754a1a7..f15c2a7b2 100644 --- a/api/swagger.yml +++ b/api/swagger.yml @@ -2173,6 +2173,12 @@ definitions: type: integer format: uint16 description: probe port if probetype is tcp/udp/sctp + probereq: + type: string + description: probe request string + proberesp: + type: string + description: probe response string managed: type: boolean description: externally managed rule or not diff --git a/common/common.go b/common/common.go index f7ba1b15a..6cf435887 100644 --- a/common/common.go +++ b/common/common.go @@ -500,10 +500,14 @@ type LbServiceArg struct { InactiveTimeout uint32 `json:"inactiveTimeout"` // Managed - This rule is managed by external entity e.g k8s Managed bool `json:"managed"` - // ProbeType - Liveness check type for this rule : ping, tcp, udp, sctp, none + // ProbeType - Liveness check type for this rule : ping, tcp, udp, sctp, none, http(s) ProbeType string `json:"probetype"` - // ProbePort - Liveness check port number. Only valid for tcp, udp, sctp + // ProbePort - Liveness check port number. Only valid for tcp, udp, sctp, http(s) ProbePort uint16 `json:"probeport"` + // ProbeReq - Request string for liveness check + ProbeReq string `json:"probereq"` + // ProbeResp - Response string for liveness check + ProbeResp string `json:"proberesp"` } // LbEndPointArg - Information related to load-balancer end-point diff --git a/loxinet/loxinet.go b/loxinet/loxinet.go index c9f8603db..0dd671e24 100644 --- a/loxinet/loxinet.go +++ b/loxinet/loxinet.go @@ -22,7 +22,6 @@ import ( apiserver "github.com/loxilb-io/loxilb/api" nlp "github.com/loxilb-io/loxilb/api/loxinlp" prometheus "github.com/loxilb-io/loxilb/api/prometheus" - restapi "github.com/loxilb-io/loxilb/api/restapi" cmn "github.com/loxilb-io/loxilb/common" opts "github.com/loxilb-io/loxilb/options" tk "github.com/loxilb-io/loxilib" @@ -185,7 +184,7 @@ func loxiNetTicker() { } else if sig == syscall.SIGINT || sig == syscall.SIGTERM { tk.LogIt(tk.LogCritical, "Shutdown on sig %v\n", sig) mh.dpEbpf.DpEbpfUnInit() - restapi.ServerSigShutOk() + apiserver.ApiServerShutOk() } case t := <-mh.ticker.C: tk.LogIt(-1, "Tick at %v\n", t) diff --git a/loxinet/rules.go b/loxinet/rules.go index 8922a53e9..20dfea2dd 100644 --- a/loxinet/rules.go +++ b/loxinet/rules.go @@ -247,6 +247,8 @@ type ruleProbe struct { actChk bool prbType string prbPort uint16 + prbReq string + prbResp string } type ruleEnt struct { @@ -730,6 +732,8 @@ func (R *RuleH) GetNatLbRule() ([]cmn.LbRuleMod, error) { ret.Serv.Managed = data.managed ret.Serv.ProbeType = data.hChk.prbType ret.Serv.ProbePort = data.hChk.prbPort + ret.Serv.ProbeReq = data.hChk.prbReq + ret.Serv.ProbeResp = data.hChk.prbResp for _, sip := range data.secIP { ret.SecIPs = append(ret.SecIPs, cmn.LbSecIpArg{SecIP: sip.sIP.String()}) @@ -808,6 +812,8 @@ func (R *RuleH) modNatEpHost(r *ruleEnt, endpoints []ruleNatEp, doAddOp bool, li // override per end-point liveness settings hopts.probeType = r.hChk.prbType hopts.probePort = r.hChk.prbPort + hopts.probeReq = r.hChk.prbReq + hopts.probeResp = r.hChk.prbResp } else { hopts.probeType = pType hopts.probePort = pPort @@ -1138,7 +1144,8 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, e.mark = false } - if eRule.hChk.prbType != serv.ProbeType || eRule.hChk.prbPort != serv.ProbePort { + if eRule.hChk.prbType != serv.ProbeType || eRule.hChk.prbPort != serv.ProbePort || + eRule.hChk.prbReq != serv.ProbeReq || eRule.hChk.prbResp != serv.ProbeResp { ruleChg = true } @@ -1149,6 +1156,8 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, // Update the rule eRule.hChk.prbType = serv.ProbeType eRule.hChk.prbPort = serv.ProbePort + eRule.hChk.prbReq = serv.ProbeReq + eRule.hChk.prbResp = serv.ProbeResp eRule.act.action.(*ruleNatActs).sel = natActs.sel eRule.act.action.(*ruleNatActs).endPoints = eEps eRule.act.action.(*ruleNatActs).mode = natActs.mode @@ -1180,6 +1189,8 @@ func (R *RuleH) AddNatLbRule(serv cmn.LbServiceArg, servSecIPs []cmn.LbSecIpArg, // lb end-point health monitoring r.hChk.prbType = serv.ProbeType r.hChk.prbPort = serv.ProbePort + r.hChk.prbReq = serv.ProbeReq + r.hChk.prbResp = serv.ProbeResp r.hChk.actChk = serv.Monitor r.act.action = &natActs r.ruleNum, err = R.tables[RtLB].Mark.GetCounter()