// Locked version of checking if events system running. Also checks server.
167666
func (s *Server) eventsRunning() bool {
	s.mu.Lock()
	er := s.running && s.eventsEnabled()
	s.mu.Unlock()
	return er
}
516534
func (sc *SigChain) CheckFreshness(srv *MerkleTriple) (current bool, err error) {
	cli := sc.GetCurrentTailTriple()

	future := sc.GetFutureChainTail()
	Efn := NewServerChainError
	sc.G().Log.Debug("+ CheckFreshness")
	defer sc.G().Log.Debug("- CheckFreshness (%s) -> (%v,%s)", sc.uid, current, ErrToOk(err))
	a := keybase1.Seqno(-1)
	b := keybase1.Seqno(-1)

	if srv != nil {
		sc.G().Log.Debug("| Server triple: %v", srv)
		b = srv.Seqno
	} else {
		sc.G().Log.Debug("| Server triple=nil")
	}
	if cli != nil {
		sc.G().Log.Debug("| Client triple: %v", cli)
		a = cli.Seqno
	} else {
		sc.G().Log.Debug("| Client triple=nil")
	}
	if future != nil {
		sc.G().Log.Debug("| Future triple: %v", future)
	} else {
		sc.G().Log.Debug("| Future triple=nil")
	}

	if srv == nil && cli != nil {
		err = Efn("Server claimed not to have this user in its tree (we had v=%d)", cli.Seqno)
		return
	}

	if srv == nil {
		return
	}

	if b < 0 || a > b {
		err = Efn("Server version-rollback suspected: Local %d > %d", a, b)
		return
	}

	if b == a {
		sc.G().Log.Debug("| Local chain version is up-to-date @ version %d", b)
		current = true
		if cli == nil {
			err = Efn("Failed to read last link for user")
			return
		}
		if !cli.LinkID.Eq(srv.LinkID) {
			err = Efn("The server returned the wrong sigchain tail")
			return
		}
	} else {
		sc.G().Log.Debug("| Local chain version is out-of-date: %d < %d", a, b)
		current = false
	}

	if current && future != nil && (cli == nil || cli.Seqno < future.Seqno) {
		sc.G().Log.Debug("| Still need to reload, since locally, we know seqno=%d is last", future.Seqno)
		current = false
	}

	return
}
82363
func (es *EventSystem) eventLoop() {
	// Ensure all subscriptions get cleaned up
	defer func() {
		es.pendingLogSub.Unsubscribe()
		es.txsSub.Unsubscribe()
		es.logsSub.Unsubscribe()
		es.rmLogsSub.Unsubscribe()
		es.chainSub.Unsubscribe()
	}()

	index := make(filterIndex)
	for i := UnknownSubscription; i < LastIndexSubscription; i++ {
		index[i] = make(map[rpc.ID]*subscription)
	}

	for {
		select {
		// Handle subscribed events
		case ev := <-es.txsCh:
			es.broadcast(index, ev)
		case ev := <-es.logsCh:
			es.broadcast(index, ev)
		case ev := <-es.rmLogsCh:
			es.broadcast(index, ev)
		case ev := <-es.chainCh:
			es.broadcast(index, ev)
		case ev, active := <-es.pendingLogSub.Chan():
			if !active { // system stopped
				return
			}
			es.broadcast(index, ev)

		case f := <-es.install:
			if f.typ == MinedAndPendingLogsSubscription {
				// the type are logs and pending logs subscriptions
				index[LogsSubscription][f.id] = f
				index[PendingLogsSubscription][f.id] = f
			} else {
				index[f.typ][f.id] = f
			}
			close(f.installed)

		case f := <-es.uninstall:
			if f.typ == MinedAndPendingLogsSubscription {
				// the type are logs and pending logs subscriptions
				delete(index[LogsSubscription], f.id)
				delete(index[PendingLogsSubscription], f.id)
			} else {
				delete(index[f.typ], f.id)
			}
			close(f.err)

		// System stopped
		case <-es.txsSub.Err():
			return
		case <-es.logsSub.Err():
			return
		case <-es.rmLogsSub.Err():
			return
		case <-es.chainSub.Err():
			return
		}
	}
}
729001
func (d *memCacheClient) refreshLocked() error {
	// TODO: Could this multiplicative set of calls be replaced by a single call
	// to ServerResources? If it's possible for more than one resulting
	// APIResourceList to have the same GroupVersion, the lists would need merged.
	gl, err := d.delegate.ServerGroups()
	if err != nil || len(gl.Groups) == 0 {
		utilruntime.HandleError(fmt.Errorf("couldn't get current server API group list: %v", err))
		return err
	}

	rl := map[string]*cacheEntry{}
	for _, g := range gl.Groups {
		for _, v := range g.Versions {
			r, err := d.serverResourcesForGroupVersion(v.GroupVersion)
			rl[v.GroupVersion] = &cacheEntry{r, err}
			if err != nil {
				utilruntime.HandleError(fmt.Errorf("couldn't get resource list for %v: %v", v.GroupVersion, err))
			}
		}
	}

	d.groupToServerResources, d.groupList = rl, gl
	d.cacheValid = true
	return nil
}
857250
func (hs *serverHandshakeState) checkForResumption() bool {
	c := hs.c

	if c.config.SessionTicketsDisabled {
		return false
	}

	var ok bool
	var sessionTicket = append([]uint8{}, hs.clientHello.sessionTicket...)
	if hs.sessionState, ok = c.decryptTicket(sessionTicket); !ok {
		return false
	}

	if hs.sessionState.vers > hs.clientHello.vers {
		return false
	}
	if vers, ok := c.config.mutualVersion(hs.sessionState.vers); !ok || vers != hs.sessionState.vers {
		return false
	}

	cipherSuiteOk := false
	// Check that the client is still offering the ciphersuite in the session.
	for _, id := range hs.clientHello.cipherSuites {
		if id == hs.sessionState.cipherSuite {
			cipherSuiteOk = true
			break
		}
	}
	if !cipherSuiteOk {
		return false
	}

	// Check that we also support the ciphersuite from the session.
	if !hs.setCipherSuite(hs.sessionState.cipherSuite, c.config.cipherSuites(), hs.sessionState.vers) {
		return false
	}

	sessionHasClientCerts := len(hs.sessionState.certificates) != 0
	needClientCerts := c.config.ClientAuth == RequireAnyClientCert || c.config.ClientAuth == RequireAndVerifyClientCert
	if needClientCerts && !sessionHasClientCerts {
		return false
	}
	if sessionHasClientCerts && c.config.ClientAuth == NoClientCert {
		return false
	}

	return true
}
315921
func (b *backend) ProcessEvents(events ...*auditinternal.Event) bool {
	for _, d := range b.GetDelegates() {
		d.ProcessEvents(events...)
	}
	// Returning true regardless of results, since dynamic audit backends
	// can never cause apiserver request to fail.
	return true
}
1069660
func (b Backend) ProcessEvents(events ...*auditinternal.Event) bool {
	for _, event := range events {
		if event == nil {
			continue
		}
		attr, err := ev.NewAttributes(event)
		if err != nil {
			audit.HandlePluginError(PluginName, err, event)
			continue
		}
		level, stages := b.policyChecker.LevelAndStages(attr)
		if level == auditinternal.LevelNone {
			continue
		}
		// make shallow copy before modifying to satisfy interface definition
		ev := *event
		e, err := policy.EnforcePolicy(&ev, level, stages)
		if err != nil {
			audit.HandlePluginError(PluginName, err, event)
			continue
		}
		if e == nil {
			continue
		}
		b.delegateBackend.ProcessEvents(e)
	}
	// Returning true regardless of results, since dynamic audit backends
	// can never cause apiserver request to fail.
	return true
}
505235
func isWaitable(pid int) (bool, error) {
	si := &siginfo{}
	_, _, e := unix.Syscall6(unix.SYS_WAITID, _P_PID, uintptr(pid), uintptr(unsafe.Pointer(si)), unix.WEXITED|unix.WNOWAIT|unix.WNOHANG, 0, 0)
	if e != 0 {
		return false, os.NewSyscallError("waitid", e)
	}

	return si.si_pid != 0, nil
}
1330966
func (s *Server) Check(ctx context.Context, in *healthpb.HealthCheckRequest) (*healthpb.HealthCheckResponse, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if servingStatus, ok := s.statusMap[in.Service]; ok {
		return &healthpb.HealthCheckResponse{
			Status: servingStatus,
		}, nil
	}
	return nil, status.Error(codes.NotFound, "unknown service")
}
851368
func (client *DockerClient) monitorEvents(monitorId int64, uri string, callback EventCallback) {
	err := client.sendRequestCallback("GET", uri, nil, nil, func(resp *http.Response) error {
		decoder := json.NewDecoder(resp.Body)
		client.monitorLock.RLock()
		_, toContinue := client.monitors[monitorId]
		client.monitorLock.RUnlock()
		for toContinue {
			var event Event
			if err := decoder.Decode(&event); err != nil {
				return err
			}
			callback(event, nil)
			client.monitorLock.RLock()
			_, toContinue = client.monitors[monitorId]
			client.monitorLock.RUnlock()
		}
		return nil
	}, nil, true)
	if err != nil && err != io.EOF {
		callback(Event{}, err)
	}
}
1367583
func (e *EventListener) IsClosed() bool {
	e.closedMtx.RLock()
	defer e.closedMtx.RUnlock()
	return e.closed
}
327790
func (r *ready) check() bool {
	rwMutex := r.c.L.(*sync.RWMutex)
	rwMutex.RLock()
	defer rwMutex.RUnlock()
	return r.ok
}
723711
func (m *model) checkFolderRunningLocked(folder string) error {
	_, ok := m.folderRunners[folder]
	if ok {
		return nil
	}

	if cfg, ok := m.cfg.Folder(folder); !ok {
		return errFolderMissing
	} else if cfg.Paused {
		return ErrFolderPaused
	}

	return errFolderNotRunning
}
243081
func (md *MDServerRemote) signalObserverLocked(observerChan chan<- error, id tlf.ID, err error) {
	if observerChan != nil {
		observerChan <- err
		close(observerChan)
	}
	delete(md.observers, id)
}
875054
func (pool *serverPool) eventLoop() {
	lookupCnt := 0
	var convTime mclock.AbsTime
	if pool.discSetPeriod != nil {
		pool.discSetPeriod <- time.Millisecond * 100
	}

	// disconnect updates service quality statistics depending on the connection time
	// and disconnection initiator.
	disconnect := func(req *disconnReq, stopped bool) {
		// Handle peer disconnection requests.
		entry := req.entry
		if entry.state == psRegistered {
			connAdjust := float64(mclock.Now()-entry.regTime) / float64(targetConnTime)
			if connAdjust > 1 {
				connAdjust = 1
			}
			if stopped {
				// disconnect requested by ourselves.
				entry.connectStats.add(1, connAdjust)
			} else {
				// disconnect requested by server side.
				entry.connectStats.add(connAdjust, 1)
			}
		}
		entry.state = psNotConnected

		if entry.knownSelected {
			pool.knownSelected--
		} else {
			pool.newSelected--
		}
		pool.setRetryDial(entry)
		pool.connWg.Done()
		close(req.done)
	}

	for {
		select {
		case entry := <-pool.timeout:
			if !entry.removed {
				pool.checkDialTimeout(entry)
			}

		case entry := <-pool.enableRetry:
			if !entry.removed {
				entry.delayedRetry = false
				pool.updateCheckDial(entry)
			}

		case adj := <-pool.adjustStats:
			switch adj.adjustType {
			case pseBlockDelay:
				adj.entry.delayStats.add(float64(adj.time), 1)
			case pseResponseTime:
				adj.entry.responseStats.add(float64(adj.time), 1)
				adj.entry.timeoutStats.add(0, 1)
			case pseResponseTimeout:
				adj.entry.timeoutStats.add(1, 1)
			}

		case node := <-pool.discNodes:
			if pool.trustedNodes[node.ID()] == nil {
				entry := pool.findOrNewNode(node)
				pool.updateCheckDial(entry)
			}

		case conv := <-pool.discLookups:
			if conv {
				if lookupCnt == 0 {
					convTime = mclock.Now()
				}
				lookupCnt++
				if pool.fastDiscover && (lookupCnt == 50 || time.Duration(mclock.Now()-convTime) > time.Minute) {
					pool.fastDiscover = false
					if pool.discSetPeriod != nil {
						pool.discSetPeriod <- time.Minute
					}
				}
			}

		case req := <-pool.connCh:
			if pool.trustedNodes[req.p.ID()] != nil {
				// ignore trusted nodes
				req.result <- nil
			} else {
				// Handle peer connection requests.
				entry := pool.entries[req.p.ID()]
				if entry == nil {
					entry = pool.findOrNewNode(req.node)
				}
				if entry.state == psConnected || entry.state == psRegistered {
					req.result <- nil
					continue
				}
				pool.connWg.Add(1)
				entry.peer = req.p
				entry.state = psConnected
				addr := &poolEntryAddress{
					ip:       req.node.IP(),
					port:     uint16(req.node.TCP()),
					lastSeen: mclock.Now(),
				}
				entry.lastConnected = addr
				entry.addr = make(map[string]*poolEntryAddress)
				entry.addr[addr.strKey()] = addr
				entry.addrSelect = *newWeightedRandomSelect()
				entry.addrSelect.update(addr)
				req.result <- entry
			}

		case req := <-pool.registerCh:
			// Handle peer registration requests.
			entry := req.entry
			entry.state = psRegistered
			entry.regTime = mclock.Now()
			if !entry.known {
				pool.newQueue.remove(entry)
				entry.known = true
			}
			pool.knownQueue.setLatest(entry)
			entry.shortRetry = shortRetryCnt
			close(req.done)

		case req := <-pool.disconnCh:
			// Handle peer disconnection requests.
			disconnect(req, req.stopped)

		case <-pool.quit:
			if pool.discSetPeriod != nil {
				close(pool.discSetPeriod)
			}

			// Spawn a goroutine to close the disconnCh after all connections are disconnected.
			go func() {
				pool.connWg.Wait()
				close(pool.disconnCh)
			}()

			// Handle all remaining disconnection requests before exit.
			for req := range pool.disconnCh {
				disconnect(req, true)
			}
			pool.saveNodes()
			pool.wg.Done()
			return
		}
	}
}
824351
func (s Status) Event_type() string {
	switch s.String() {
	case TPL_HOSTINFOS_RUN:
		return OBCHOSTINFOSTPLRUN
	case TPL_HOSTINFOS_FINISHED:
		return OBCHOSTINFOSTPLFINISHED
	case CMD_GETCONFIG_BEGIN:
		return OBCHOSTINFOSCONFIGPARSING
	case CMD_GETCONFIG_END:
		return OBCHOSTINFOSCONFIGPARSED
	case CMD_KVMCHECK_BEGIN:
		return OBCHOSTINFOSKVMCHECKPARSING
	case CMD_KVMCHECK_END:
		return OBCHOSTINFOSKVMCHECKPARSED
	case TPL_VERTICE_RUN:
		return OBCVERTICETPLRUN
	case VERTICE_INSTALL_BEGIN:
		return OBCVERTICEINSTALLINGTYPE
	case VERTICE_INSTALL_END:
		return OBCVERTICEINSTALLEDTYPE
	case TPL_VERTICE_FINISHED:
		return OBCVERTICETPLFINISHED
	case TPL_VERTICEGATEWAY_RUN:
		return OBCVERTICEGATEWAYTPLRUN
	case GATEWAY_INSTALL_BEGIN:
		return OBCVERTICEGATEWAYINSTALLINGTYPE
	case GATEWAY_INSTALL_END:
		return OBCVERTICEGATEWAYINSTALLEDTYPE
	case TPL_VERTICEGATEWAY_FINISHED:
		return OBCVERTICEGATEWAYTPLFINISHED
	case TPL_VERTICENILAVU_RUN:
		return OBCVERTICENILAVUTPLRUN
	case NILAVU_INSTALL_BEGIN:
		return OBCVERTICENILAVUINSTALLINGTYPE
	case NILAVU_INSTALL_END:
		return OBCVERTICENILAVUINSTALLEDTYPE
	case TPL_VERTICENILAVU_FINISHED:
		return OBCVERTICENILAVUTPLFINISHED
	case TPL_ONEMASTER_RUN:
		return OBCONEMASTERTPLRUN
	case ONEMASTER_INSTALL_BEGIN:
		return OBCONEMASTERINSTALLINGTYPE
	case ONEMASTER_INSTALL_END:
		return OBCONEMASTERINSTALLEDTYPE
	case ONEMASTER_ACTIVATE_BEGIN:
		return OBCONEMASTERACTIVATINGTYPE
	case ONEMASTER_ACTIVATE_END:
		return OBCONEMASTERACTIVATEDTYPE
	case TPL_ONEMASTER_FINISHED:
		return OBCONEMASTERTPLFINISHED
	case TPL_ONEHOST_RUN:
		return OBCONEHOSTTPLRUN
	case ONEHOST_PEPARE_BEGIN:
		return OBCONEHOSTPEPARINGTYPE
	case ONEHOST_PREPARE_END:
		return OBCONEHOST_PREPAREDTYPE
	case ONEHOST_INSTALL_BEGIN:
		return OBCONEHOSTINSTALLINGTYPE
	case ONEHOST_INSTALL_END:
		return OBCONEHOSTINSTALLEDTYPE
	case TPL_ONEHOST_FINISHED:
		return OBCONEHOSTTPLFINISHEDTYPE
	case TPL_CEPHCLUSTER_RUN:
		return OBCCEPHCLUSTERTPLRUN
	case CEPHCLUSTER_PREPARE_BEGIN:
		return OBCCEPHCLUSTERPREPAREINSTALLINGTYPE
	case CEPHCLUSTER_PREPARE_END:
		return OBCCEPHCLUSTERPREPAREINSTALLEDTYPE
	case CEPHCLUSTER_INSTALL_BEIGIN:
		return OBCCEPHCLUSTERINSTALLINGTYPE
	case CEPHCLUSTER_INSTALL_END:
		return OBCCEPHCLUSTERINSTALLEDTYPE
	case CEPHCLUSTER_ACCESS_BEGIN:
		return OBCCEPHCLUSTERACCESSENABLINGTYPE
	case CEPHCLUSTER_ACCESS_END:
		return OBCCEPHCLUSTERACCESSENABLEDTYPE
	case CEPHCLUSTER_NEW_BEGIN:
		return OBCCEPHCLUSTERNEWCREATINGTYPE
	case CEPHCLUSTER_NEW_END:
		return OBCCEPHCLUSTERNEWCREATEDTYPE
	case CEPHCLUSTER_CONFIG_BEGIN:
		return OBCCEPHCLUSTERCONFIGURINGTYPE
	case CEPHCLUSTER_CONFIG_END:
		return OBCCEPHCLUSTERCONFIGUREDTYPE
	case CEPHCLUSTER_MON_BEGIN:
		return OBCCEPHCLUSTERMONINITIALINGTYPE
	case CEPHCLUSTER_MON_END:
		return OBCCEPHCLUSTERMONINITIALIZEDTYPE
	case CEPHCLUSTER_CREATEPOOL_BEGIN:
		return OBCCEPHCLUSTERPOOLCREATINGTYPE
	case CEPHCLUSTER_CREATEPOOL_END:
		return OBCCEPHCLUSTERPOOLCREATEDTYPE
	case TPL_CEPHCLUSTER_FINISHED:
		return OBCCEPHCLUSTERTPLFINISHED
	case TPL_CEPHCLIENT_RUN:
		return OBCCEPHCLIENTTPLRUN
	case CEPHCLIENT_INSTALL_BEGIN:
		return OBCCEPHCLIENTINSTALLING
	case CEPHCLIENT_INSTALL_END:
		return OBCCEPHCLIENTINSTALLED
	case TPL_CEPHCLIENT_FINISHED:
		return OBCCEPHCLIENTTPLFINISHED
	case TPL_ADDOSDS_RUN:
		return OBCADDOSDSTPLRUN
	case OSDS_ACTIVATE_BEGIN:
		return OBCOSDSACTIVATINGTYPE
	case OSDS_ACTIVATE_END:
		return OBCOSDSACTIVATEDTYPE
	case OSDS_PREPARE_BEGIN:
		return OBCOSDSPREPARINGTYPE
	case OSDS_PREPARE_END:
		return OBCOSDSPREPAREDTYPE
	case TPL_ADDOSDS_FINISHED:
		return OBCADDOSDSTPLFINISHED
	case TPL_DSCONNECTION_RUN:
		return OBCCEPHDSCONNECTIONTPLRUN
	case CEPHDS_AUTHKEY_BEGIN:
		return OBCCEPHDSAUTHKEYCREATINGTYPE
	case CEPHDS_AUTHKEY_END:
		return OBCCEPHDSAUTHKEYCREATEDTYPE
	case CEPHDS_DEFINEKEY_BEGIN:
		return OBCCEPHDSAUTHKEYDEFININGTYPE
	case CEPHDS_DEFINEKEY_END:
		return OBCCEPHDSAUTHKEYDEFINEDTYPE
	case TPL_DSCONNECTION_FINISHED:
		return OBCCEPHDSCONNECTIONTPLFINISHED
	case TPL_CEPHACCESS_RUN:
		return OBCCEPHACCESSTPLRUN
	case CEPHACCESS_PASSWORD_BEGIN:
		return OBCCEPHACCESSPASSAUTHENDICATINGTYPE
	case CEPHACCESS_PASSWORD_END:
		return OBCCEPHACCESSPASSAUTHENDICATEDTYPE
	case CEPHACCESS_KEY_BEGIN:
		return OBCCEPHACCESSKEYAUTHENDICATINGTYPE
	case CEPHACCESS_KEY_END:
		return OBCCEPHACCESSKEYAUTHENDICATEDTYPE
	case TPL_CEPHACCESS_FINISHED:
		return OBCCEPHACCESSTPLFINISHED
	case TPL_ZAPDISK_RUN:
		return OBCZAPDISKTPLRUN
	case ZAPDISKS_CLEAN_BEGIN:
		return OBCZAPDISKSCLEANINGTYPE
	case ZAPDISKS_CLEAN_END:
		return OBCZAPDISKSCLEANEDTYPE
	case TPL_ZAPDISK_FINISHED:
		return OBCZAPDISKTPLFINISHED
	case TPL_KVMNETWORK_RUN:
		return OBCKVMNETWORKTPLRUN
	case KVMNETWORK_CONFIG_BEGIN:
		return OBCKVMNETWORKCONFIGURINGTYPE
	case KVMNETWORK_CONFIG_END:
		return OBCKVMNETWORKCONFIGUREDTYPE
	case TPL_KVMNETWORK_FINISHED:
		return OBCKVMNETWORKTPLFINISHED
	case TPL_LVMINSTALL_RUN:
		return OBCLVMTPLRUN
	case LVM_INSTALL_BEGIN:
		return OBCLVM_INSTALLINGTYPE
	case LVM_INSTALL_END:
		return OBCLVMINSTALLEDTYPE
	case TPL_LVMINSTALL_FINISHED:
		return OBCLVMTPLFINISHED
	case TPL_NETWORKINFO_RUN:
		return OBCNETWORKINFOTPLRUN
	case GETNETWORK_INFOS_BEGIN:
		return OBCGETNETWORKINFOSGATHERINGTYPE
	case GETNETWORK_INFOS_END:
		return OBCGETNETWORKINFOSGATHEREDTYPE
	case TPL_NETWORKINFO_FINISHED:
		return OBCNETWORKINFOTPLFINISHED
	case RUNNING:
		return OBCHOSTINSTALLRUNNINGTYPE
	case HOSTRUNNING:
		return OBCHOSTINSTALLRUNNINGTYPE
	case MASTERRUNNING:
		return OBCHOSTINSTALLRUNNINGTYPE
	case NETWORKERROR:
		return OBCNETWORKERRORTYPE
	case STORAGEERROR:
		return OBCSTORAGEERRORTYPE
	case COMPUTEERROR:
		return OBCCOMPUTEERRORTYPE
	case PREERROR:
		return OBCTEMPLATEPREERRORTYPE
	case POSTERROR:
		return OBCTEMPLATEPOSTERRORTYPE
	case ERROR:
		return OBCTEPMLATEERRORTYPE
	default:
		return "arrgh"
	}
}
1189487
func startLockMaintenance(lkSrv *lockRESTServer) {
	// Initialize a new ticker with a minute between each ticks.
	ticker := time.NewTicker(lockMaintenanceInterval)
	// Stop the timer upon service closure and cleanup the go-routine.
	defer ticker.Stop()

	// Start with random sleep time, so as to avoid "synchronous checks" between servers
	time.Sleep(time.Duration(rand.Float64() * float64(lockMaintenanceInterval)))
	for {
		// Verifies every minute for locks held more than 2 minutes.
		select {
		case <-GlobalServiceDoneCh:
			return
		case <-ticker.C:
			lkSrv.lockMaintenance(lockValidityCheckInterval)
		}
	}
}