// Attempts to claim a lock. If the overrideLock is set, any existing lock holder
// will be destroyed and one more attempt will be made to acquire the lock
func (r *replication) lock(session kp.Session, lockPath string, overrideLock bool) (consulutil.Unlocker, error) {
unlocker, err := session.Lock(lockPath)
if _, ok := err.(consulutil.AlreadyLockedError); ok {
holder, id, err := r.store.LockHolder(lockPath)
if err != nil {
return nil, util.Errorf("Lock already held for %q, could not determine holder due to error: %s", lockPath, err)
} else if holder == "" {
// we failed to acquire this lock, but there is no outstanding
// holder
// this indicates that the previous holder had a LockDelay,
// which prevents other parties from acquiring the lock for a
// limited time
return nil, util.Errorf("Lock for %q is blocked due to delay by previous holder", lockPath)
} else if overrideLock {
err = r.store.DestroyLockHolder(id)
if err != nil {
return nil, util.Errorf("Unable to destroy the current lock holder (%s) for %q: %s", holder, lockPath, err)
}
// try acquiring the lock again, but this time don't destroy holders so we don't try forever
return r.lock(session, lockPath, false)
} else {
return nil, util.Errorf("Lock for %q already held by lock %q", lockPath, holder)
}
}
return unlocker, err
}
// Acquires a lock on the DS that should be used by DS farm goroutines, whose
// job it is to carry out the intent of the DS
func (s *consulStore) LockForOwnership(dsID fields.ID, session kp.Session) (consulutil.Unlocker, error) {
lockPath, err := s.dsLockPath(dsID)
if err != nil {
return nil, err
}
return session.Lock(lockPath)
}
func (s *FakeDSStore) LockForOwnership(dsID fields.ID, session kp.Session) (consulutil.Unlocker, error) {
lockPath, err := s.dsLockPath(dsID)
if err != nil {
return nil, err
}
s.logger.Logger.Infof("Locking daemon set on the following path: '%v'", lockPath)
return session.Lock(lockPath)
}
// Acquires a lock on the RC for ensuring that no two rolling updates are
// created that operate on the same replication controllers. A lock on both
// the intended "new" and "old" replication controllers should be held before
// the update is created.
func (s *consulStore) LockForUpdateCreation(rcID fields.ID, session kp.Session) (consulutil.Unlocker, error) {
updateCreationLockPath, err := s.updateCreationLockPath(rcID)
if err != nil {
return nil, err
}
return session.Lock(updateCreationLockPath)
}
func (s *fakeStore) LockForUpdateCreation(rcID fields.ID, session kp.Session) (consulutil.Unlocker, error) {
key := fmt.Sprintf("%s/%s", rcID, "update_creation_lock")
return session.Lock(key)
}
func (s *fakeStore) LockForOwnership(rcID fields.ID, session kp.Session) (consulutil.Unlocker, error) {
key := fmt.Sprintf("%s/%s", rcID, "ownership_lock")
return session.Lock(key)
}