open-consul/agent/consul/session_ttl.go

159 lines
4.5 KiB
Go
Raw Normal View History

package consul
import (
"fmt"
"time"
2014-12-12 23:43:34 +00:00
2014-12-19 00:57:49 +00:00
"github.com/armon/go-metrics"
2020-11-14 00:26:08 +00:00
"github.com/armon/go-metrics/prometheus"
"github.com/hashicorp/consul/agent/structs"
)
var SessionGauges = []prometheus.GaugeDefinition{
{
Name: []string{"session_ttl", "active"},
2020-11-16 19:02:11 +00:00
Help: "Tracks the active number of sessions being tracked.",
},
{
Name: []string{"raft", "applied_index"},
2020-11-23 21:06:30 +00:00
Help: "Represents the raft applied index.",
},
{
Name: []string{"raft", "last_index"},
2020-11-23 21:06:30 +00:00
Help: "Represents the raft last index.",
},
}
var SessionSummaries = []prometheus.SummaryDefinition{
{
Name: []string{"session_ttl", "invalidate"},
2020-11-16 19:02:11 +00:00
Help: "Measures the time spent invalidating an expired session.",
},
}
const (
// maxInvalidateAttempts limits how many invalidate attempts are made
maxInvalidateAttempts = 6
// invalidateRetryBase is a baseline retry time
invalidateRetryBase = 10 * time.Second
)
2015-09-15 12:22:08 +00:00
// initializeSessionTimers is used when a leader is newly elected to create
2014-12-12 23:43:34 +00:00
// a new map to track session expiration and to reset all the timers from
// the previously known set of timers.
func (s *Server) initializeSessionTimers() error {
2014-12-12 23:43:34 +00:00
// Scan all sessions and reset their timer
state := s.fsm.State()
2021-12-03 22:23:55 +00:00
_, sessions, err := state.SessionListAll(nil)
if err != nil {
return err
}
for _, session := range sessions {
2021-12-03 22:23:55 +00:00
if err := s.resetSessionTimer(session); err != nil {
return err
}
}
return nil
}
2014-12-12 23:43:34 +00:00
// resetSessionTimer is used to renew the TTL of a session.
// This can be used for new sessions and existing ones. A session
// will be faulted in if not given.
2021-12-03 22:23:55 +00:00
func (s *Server) resetSessionTimer(session *structs.Session) error {
// Bail if the session has no TTL, fast-path some common inputs
2014-12-12 23:43:34 +00:00
switch session.TTL {
case "", "0", "0s", "0m", "0h":
return nil
}
2014-12-12 23:43:34 +00:00
// Parse the TTL, and skip if zero time
ttl, err := time.ParseDuration(session.TTL)
if err != nil {
return fmt.Errorf("Invalid Session TTL '%s': %v", session.TTL, err)
}
if ttl == 0 {
return nil
}
s.createSessionTimer(session.ID, ttl, &session.EnterpriseMeta)
2014-12-12 23:43:34 +00:00
return nil
}
func (s *Server) createSessionTimer(id string, ttl time.Duration, entMeta *structs.EnterpriseMeta) {
// Reset the session timer
2014-12-12 23:43:34 +00:00
// Adjust the given TTL by the TTL multiplier. This is done
// to give a client a grace period and to compensate for network
// and processing delays. The contract is that a session is not expired
// before the TTL, but there is no explicit promise about the upper
// bound so this is allowable.
ttl = ttl * structs.SessionTTLMultiplier
s.sessionTimers.ResetOrCreate(id, ttl, func() { s.invalidateSession(id, entMeta) })
}
2014-12-12 23:43:34 +00:00
// invalidateSession is invoked when a session TTL is reached and we
// need to invalidate the session.
func (s *Server) invalidateSession(id string, entMeta *structs.EnterpriseMeta) {
defer metrics.MeasureSince([]string{"session_ttl", "invalidate"}, time.Now())
2014-12-12 23:43:34 +00:00
// Clear the session timer
s.sessionTimers.Del(id)
2014-12-12 23:43:34 +00:00
// Create a session destroy request
args := structs.SessionRequest{
Datacenter: s.config.Datacenter,
Op: structs.SessionDestroy,
Session: structs.Session{
ID: id,
},
}
if entMeta != nil {
args.Session.EnterpriseMeta = *entMeta
}
2014-12-12 23:43:34 +00:00
// Retry with exponential backoff to invalidate the session
for attempt := uint(0); attempt < maxInvalidateAttempts; attempt++ {
_, err := s.raftApply(structs.SessionRequestType, args)
if err == nil {
s.logger.Debug("Session TTL expired", "session", id)
return
}
s.logger.Error("Invalidation failed", "error", err)
time.Sleep((1 << attempt) * invalidateRetryBase)
2014-12-12 23:43:34 +00:00
}
s.logger.Error("maximum revoke attempts reached for session", "error", id)
2014-12-12 23:43:34 +00:00
}
// clearSessionTimer is used to clear the session time for
// a single session. This is used when a session is destroyed
// explicitly and no longer needed.
func (s *Server) clearSessionTimer(id string) error {
s.sessionTimers.Stop(id)
return nil
}
2014-12-12 23:43:34 +00:00
// clearAllSessionTimers is used when a leader is stepping
// down and we no longer need to track any session timers.
func (s *Server) clearAllSessionTimers() {
s.sessionTimers.StopAll()
}
2014-12-19 00:57:49 +00:00
2020-11-23 21:06:30 +00:00
// updateMetrics is a long running routine used to update a
// number of server periodic metrics
func (s *Server) updateMetrics() {
2014-12-19 00:57:49 +00:00
for {
select {
case <-time.After(time.Second):
metrics.SetGauge([]string{"session_ttl", "active"}, float32(s.sessionTimers.Len()))
2014-12-19 00:57:49 +00:00
metrics.SetGauge([]string{"raft", "applied_index"}, float32(s.raft.AppliedIndex()))
metrics.SetGauge([]string{"raft", "last_index"}, float32(s.raft.LastIndex()))
2014-12-19 00:57:49 +00:00
case <-s.shutdownCh:
return
}
}
}