@Override public boolean isPrimary() { return this.advisor.isPrimary(); }
private boolean continueVolunteering() { synchronized (BucketAdvisor.this) { // false if caller is not the volunteeringThread if (!Thread.currentThread().equals(this.volunteeringThread)) { return false; } if (!isVolunteering() && !isBecomingPrimary()) { return false; } // false if primaryMember is not null if (!isAggressive() && basicGetPrimaryMember() != null) { return false; } // false if this member is already primary if (isPrimary()) { return false; } // false if closed if (isClosed()) { return false; } // false if no longer hosting if (!isHosting()) { return false; } // must be true... need to continue volunteering return true; } }
/** * Returns the total number of datastores hosting an instance of this bucket. * * @return the total number of datastores hosting an instance of this bucket */ public int getBucketOwnersCount() { return this.advisor.getBucketRedundancy() + 1; }
private void waitIfNoPrimaryMemberFound() { synchronized (BucketAdvisor.this) { if (basicGetPrimaryMember() == null) { waitForPrimaryMember(100); if (basicGetPrimaryMember() == null) { findAndSetPrimaryMember(); } } } }
/** * If the current member is primary for this bucket return true, otherwise, give some time for the * current member to become primary and then return whether it is a primary (true/false). */ public boolean isPrimaryWithWait() { if (this.isPrimary()) { return true; } // wait for the current member to become primary holder InternalDistributedMember primary = waitForNewPrimary(); if (primary != null) { return true; } return false; }
/** * Searches through profiles to find first profile that is flagged as primary and sets * {@link #primaryMember} to it. Caller must synchronize on this BucketAdvisor. * * @return true if a primary member was found and used * @see #findAndSetPrimaryMember() */ boolean findAndSetPrimaryMember() { if (isPrimary()) { setPrimaryMember(this.getDistributionManager().getDistributionManagerId()); return true; } InternalDistributedMember[] primaryMembers = findPrimaryMembers(); if (primaryMembers.length > 0) { setPrimaryMember(primaryMembers[0]); return true; } else { return false; } }
if (!isClosed()) { // hole: requestPrimaryState not hosting initializationGate(); boolean wasPrimary = isPrimary() && this.getDistributionManager().getId().equals(member); final InternalDistributedMember currentPrimary = (InternalDistributedMember) this.primaryMember.get(); if (isClosed()) { if (isHosting()) { requestPrimaryState(NO_PRIMARY_HOSTING); if (this.pRegion.isFixedPartitionedRegion()) { InternalDistributedMember primaryMember = this.regionAdvisor.adviseFixedPrimaryPartitionDataStore(this.getBucket().getId()); if (primaryMember == null || primaryMember.equals(member)) { needToVolunteerForPrimary = true; requestPrimaryState(NO_PRIMARY_NOT_HOSTING); findAndSetPrimaryMember(); invokeAfterSecondaryInPartitionListeners(); Bucket br = this.regionAdvisor.getBucket(getBucket().getId()); if (br != null && br instanceof BucketRegion) { ((BucketRegion) br).beforeReleasingPrimaryLockDuringDemotion(); releasePrimaryLock(); deposePrimaryForColocatedChildren();
boolean wasPrimary = false; synchronized (this) { wasPrimary = isPrimary(); if (isClosed()) { return; if (hasPrimary()) { requestPrimaryState(OTHER_PRIMARY_HOSTING); } else { requestPrimaryState(NO_PRIMARY_HOSTING); needToVolunteerForPrimary = true; if (hasPrimary()) { // has primary... if (isPrimary()) { requestPrimaryState(NO_PRIMARY_NOT_HOSTING); this.primaryMember.set(null); findAndSetPrimaryMember(); } else { requestPrimaryState(OTHER_PRIMARY_NOT_HOSTING); requestPrimaryState(NO_PRIMARY_NOT_HOSTING); if (updateRedundancy() > 0 && isHosting()) { releasePrimaryLock(); volunteerForPrimary(); sendProfileUpdate();
logger.debug("Acquired primary lock for BucketID {} PR : {}", getBucket().getId(), regionAdvisor.getPartitionedRegion().getFullPath()); try { synchronized (this) { if (isHosting() && (isVolunteering() || isBecomingPrimary())) { Bucket br = this.regionAdvisor.getBucket(getBucket().getId()); if (br != null && br instanceof BucketRegion) { ((BucketRegion) br).beforeAcquiringPrimaryState(); if (requestPrimaryState(IS_PRIMARY_HOSTING)) { if (logger.isDebugEnabled()) { logger.debug("Acquired primary lock for setting primary now BucketID {} PR : {}", getBucket().getId(), regionAdvisor.getPartitionedRegion().getFullPath()); setPrimaryMember(getDistributionManager().getId()); changedStateToIsPrimary = true; if (hasPrimary() && isPrimary()) { shouldInvokeListeners = true; invokePartitionListeners(); sendProfileUpdate(); Bucket br = this.regionAdvisor.getBucket(getBucket().getId()); if (br != null && br instanceof BucketRegion) { ((BucketRegion) br).processPendingSecondaryExpires(); releasePrimaryLock();
initializationGate(); long startTime = getPartitionedRegionStats().startPrimaryTransfer(isRebalance); try { long waitTime = 2000; // time each iteration will wait while (!isPrimary()) { this.getAdvisee().getCancelCriterion().checkCancelInProgress(null); boolean attemptToBecomePrimary = false; boolean attemptToDeposePrimary = false; if (isClosed() || !isHosting()) { if (logger.isDebugEnabled()) { logger.debug("Breaking from becomePrimary loop because {} is closed or not hosting", if (isVolunteering()) { } else if (isBecomingPrimary()) { InternalDistributedMember otherPrimary = getPrimary(); if (otherPrimary != null && !getDistributionManager().getId().equals(otherPrimary)) { if (logger.isDebugEnabled()) { logger.debug("Attempting to depose primary on {} for {}", otherPrimary, this); DeposePrimaryBucketMessage.send(otherPrimary, this.pRegion, getBucket().getId()); if (response != null) { response.waitForRepliesUninterruptibly(); getPartitionedRegionStats().endPrimaryTransfer(startTime, isPrimary(), isRebalance);
false); BucketAdvisor advisor = BucketAdvisor.createBucketAdvisor(bucket, regionAdvisor); BucketAdvisor advisorSpy = spy(advisor); doCallRealMethod().when(advisorSpy).exchangeProfiles(); doCallRealMethod().when(advisorSpy).volunteerForPrimary(); doReturn(true).when(advisorSpy).initializationGate(); doReturn(true).when(advisorSpy).isHosting(); advisorSpy.setVolunteeringDelegate(volunteeringDelegate); advisorSpy.initializePrimaryElector(missingElectorId); assertEquals(missingElectorId, advisorSpy.getPrimaryElector()); advisorSpy.volunteerForPrimary(); verify(volunteeringDelegate).volunteerForPrimary();
if (colocatedWithList != null) { for (PartitionedRegion childPR : colocatedWithList) { Bucket b = childPR.getRegionAdvisor().getBucket(getBucket().getId()); BucketAdvisor childBA = b.getBucketAdvisor(); Assert.assertHoldsLock(childBA, false); logger.debug( "BucketAdvisor.acquirePrimaryRecursivelyForColocated: about to take lock for bucket: {} of PR: {} with isHosting={}", getBucket().getId(), childPR.getFullPath(), childBA.isHosting()); if (childBA.isHosting()) { if (isPrimary()) { if (!childBA.isPrimary()) { childBA.setVolunteering(); boolean acquired = childBA.acquiredPrimaryLock(); acquireForChild = true; if (acquired && this.pRegion.isFixedPartitionedRegion()) { childBA.acquirePrimaryForRestOfTheBucket(); childBA.acquirePrimaryRecursivelyForColocated();
long warnTime = getDistributionManager().getConfig().getAckWaitThreshold() * 1000L; boolean loggedWarning = false; try { for (;;) { this.getAdvisee().getCancelCriterion().checkCancelInProgress(null); final InternalCache cache = getBucket().getCache(); if (cache != null && cache.isCacheAtShutdownAll()) { throw cache.getCacheClosedException("Cache is shutting down"); if (getBucketRedundancy() == -1) { getProxyBucketRegion().getPartitionedRegion().checkReadiness(); if (isClosed()) { break; break; if (getBucketRedundancy() == -1 || isClosed()) { break; // early out... all bucket regions are gone or we closed InternalDistributedMember primary = basicGetPrimaryMember(); if (primary != null) { return primary; .warn( "{} secs have elapsed waiting for a primary for bucket {}. Current bucket owners {}", new Object[] {warnTime / 1000L, this, this.adviseInitialized()});
final ProxyBucketRegion proxyBucketRegion = bucketAdvisor.getProxyBucketRegion(); BucketPersistenceAdvisor persistentAdvisor = proxyBucketRegion.getPersistenceAdvisor(); bucketAdvisor.setPrimaryElector(newPrimary); if (bucketAdvisor.isHosting()) { bucketAdvisor.clearPrimaryElector(); bucketAdvisor.volunteerForPrimary(); if (!bucketAdvisor.adviseInitialized().contains(newPrimary)) { bucketAdvisor.clearPrimaryElector(); bucketAdvisor.volunteerForPrimary(); if (bucketAdvisor.getHadPrimary()) { bucketAdvisor.clearPrimaryElector(); bucketAdvisor.volunteerForPrimary(); bucketAdvisor.endBucketCreation();
InternalDistributedMember myId = this.partitionedRegion.getDistributionManager().getDistributionManagerId(); Lock primaryMoveReadLock = bucketAdvisor.getPrimaryMoveReadLock(); if (!forceRemovePrimary && bucketAdvisor.isPrimary()) { return false; InternalDistributedMember primary = bucketAdvisor.getPrimary(); if (!forceRemovePrimary && (primary == null || myId.equals(primary))) { if (logger.isDebugEnabled()) { if (bucketRegion.getPartitionedRegion().getColocatedWithRegion() != null) { bucketRegion.getPartitionedRegion().getColocatedWithRegion().getRegionAdvisor() .getBucketAdvisor(bucketId).setShadowBucketDestroyed(true); bucketAdvisor.getProxyBucketRegion().removeBucket(); } finally { primaryMoveReadLock.unlock(); InternalDistributedMember primary = bucketAdvisor.getPrimary(); if (!myId.equals(primary)) { StateFlushOperation flush = new StateFlushOperation(bucketRegion); bucketRegion.preDestroyBucket(bucketId); bucketRegion.localDestroyRegion(); bucketAdvisor.getProxyBucketRegion().finishRemoveBucket(); if (logger.isDebugEnabled()) { logger.debug("Destroyed {}", bucketRegion);
protected void acquirePrimaryForRestOfTheBucket() { List<FixedPartitionAttributesImpl> fpas = this.pRegion.getFixedPartitionAttributesImpl(); if (fpas != null) { int bucketId = getBucket().getId(); for (FixedPartitionAttributesImpl fpa : fpas) { if (fpa.getStartingBucketID() == bucketId) { for (int i = bucketId + 1; i <= fpa.getLastBucketID();) { Bucket b = regionAdvisor.getBucket(i++); if (b != null) { BucketAdvisor ba = b.getBucketAdvisor(); ba.primaryMoveWriteLock.lock(); try { if (ba.isHosting()) { if (!ba.isPrimary()) { ba.setVolunteering(); ba.acquiredPrimaryLock(); } } } finally { ba.primaryMoveWriteLock.unlock(); } } } } else { continue; } } } }
try { boolean acquiredLock = false; getAdvisee().getCancelCriterion().checkCancelInProgress(null); if (parentBA.isPrimary() && !isPrimary()) { acquiredLock = acquiredPrimaryLock(); } else { return; Assert.assertHoldsLock(this, false); synchronized (startingBucketAdvisor) { if (startingBucketAdvisor.isPrimary() && !isPrimary()) { acquiredLock = acquiredPrimaryLock(); } else { return; thePrimaryLock = getPrimaryLock(true); if (thePrimaryLock == null) { acquiredLock = acquiredPrimaryLock(); acquirePrimaryRecursivelyForColocated(); acquirePrimaryForRestOfTheBucket(); return;
/** * Attempt to acquire lock for primary until a primary exists. Caller hands off responsibility to * an executor (waiting pool) and returns early. */ public void volunteerForPrimary() { InternalDistributedMember elector = primaryElector; if (elector != null && regionAdvisor.hasPartitionedRegion(elector)) { // another server will determine the primary node return; } primaryElector = null; initializationGate(); synchronized (this) { if (isVolunteering() || isClosed() || !isHosting()) { // only one thread should be attempting to volunteer at one time return; } if (this.volunteeringDelegate == null) { setVolunteeringDelegate(new VolunteeringDelegate()); } this.volunteeringDelegate.volunteerForPrimary(); } }
if (this.getDistributionManager().getSystem().isLoner()) { final int bucketId = ((ProxyBucketRegion) getAdvisee()).getBucketId(); BucketProfile bp = (BucketProfile) createProfile(); updateServerBucketProfile(bp); InternalDistributedMember primary = basicGetPrimaryMember(); HashSet hostsAndProxyMembers = new HashSet(); if (primary != null && !primary.equals(getDistributionManager().getId())) { hostsAndProxyMembers.addAll(adviseGeneric()); // Add all members hosting the bucket hostsAndProxyMembers.addAll(adviseProfileUpdate()); // Add all proxy instances that could use getDistributionManager(), partitionedRegionId, bucketId, bp, true); if (reply != null) { reply.waitForRepliesUninterruptibly();
@Override protected void setInternalRegionArguments(InternalRegionArguments ira) { // PR specific PartitionedRegion pr = mock(PartitionedRegion.class); BucketAdvisor ba = mock(BucketAdvisor.class); ReadWriteLock primaryMoveLock = new ReentrantReadWriteLock(); Lock primaryMoveReadLock = primaryMoveLock.readLock(); when(ba.getPrimaryMoveReadLock()).thenReturn(primaryMoveReadLock); when(ba.getProxyBucketRegion()).thenReturn(mock(ProxyBucketRegion.class)); when(ba.isPrimary()).thenReturn(true); ira.setPartitionedRegion(pr).setPartitionedRegionBucketRedundancy(1).setBucketAdvisor(ba); }