Examples with LonerDistributionManager org.apache.geode.distributed.internal.LonerDistributionManager used on opensource projects

Example 1 with LonerDistributionManager

use of org.apache.geode.distributed.internal.LonerDistributionManager in project geode by apache.

the class PRFunctionExecutionDUnitTest method bug41118.

public static void bug41118() {
    InternalDistributedSystem ds = new PRFunctionExecutionDUnitTest().getSystem();
    assertNotNull(ds);
    ds.disconnect();
    Properties props = new Properties();
    props.setProperty(MCAST_PORT, "0");
    ds = (InternalDistributedSystem) DistributedSystem.connect(props);
    DM dm = ds.getDistributionManager();
    assertEquals("Distributed System is not loner", true, dm instanceof LonerDistributionManager);
    Cache cache = CacheFactory.create(ds);
    AttributesFactory factory = new AttributesFactory();
    factory.setDataPolicy(DataPolicy.PARTITION);
    assertNotNull(cache);
    Region region = cache.createRegion("PartitonedRegion", factory.create());
    for (int i = 0; i < 20; i++) {
        region.put("KEY_" + i, "VALUE_" + i);
    }
    Set<String> keysForGet = new HashSet<String>();
    keysForGet.add("KEY_4");
    keysForGet.add("KEY_9");
    keysForGet.add("KEY_7");
    try {
        Execution execution = FunctionService.onRegion(region).withFilter(keysForGet).setArguments(Boolean.TRUE);
        ResultCollector rc = execution.execute(new FunctionAdapter() {

            @Override
            public void execute(FunctionContext fc) {
                RegionFunctionContext context = (RegionFunctionContext) fc;
                Set keys = context.getFilter();
                Set keysTillSecondLast = new HashSet();
                int setSize = keys.size();
                Iterator keysIterator = keys.iterator();
                for (int i = 0; i < (setSize - 1); i++) {
                    keysTillSecondLast.add(keysIterator.next());
                }
                for (Object k : keysTillSecondLast) {
                    context.getResultSender().sendResult((Serializable) PartitionRegionHelper.getLocalDataForContext(context).get(k));
                }
                Object lastResult = keysIterator.next();
                context.getResultSender().lastResult((Serializable) PartitionRegionHelper.getLocalDataForContext(context).get(lastResult));
            }

            @Override
            public String getId() {
                return getClass().getName();
            }
        });
        rc.getResult();
        ds.disconnect();
    } catch (Exception e) {
        LogWriterUtils.getLogWriter().info("Exception Occurred : " + e.getMessage());
        e.printStackTrace();
        Assert.fail("Test failed", e);
    }
}

Example 2 with LonerDistributionManager

use of org.apache.geode.distributed.internal.LonerDistributionManager in project geode by apache.

the class LonerDMJUnitTest method testMemberId.

@Test
public void testMemberId() throws UnknownHostException {
    String host = InetAddress.getLocalHost().getCanonicalHostName();
    String name = "Foo";
    Properties cfg = new Properties();
    cfg.setProperty(MCAST_PORT, "0");
    cfg.setProperty(LOCATORS, "");
    cfg.setProperty(ROLES, "lonelyOne");
    cfg.setProperty(NAME, name);
    cfg.setProperty(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    DistributedSystem ds = DistributedSystem.connect(cfg);
    System.out.println("MemberId = " + ds.getMemberId());
    assertEquals(host.toString(), ds.getDistributedMember().getHost());
    assertEquals(OSProcess.getId(), ds.getDistributedMember().getProcessId());
    if (!PureJavaMode.isPure()) {
        String pid = String.valueOf(OSProcess.getId());
        assertTrue(ds.getMemberId().indexOf(pid) > -1);
    }
    assertTrue(ds.getMemberId().indexOf(name) > -1);
    String memberid = ds.getMemberId();
    String shortname = shortName(host);
    assertTrue("'" + memberid + "' does not contain '" + shortname + "'", memberid.indexOf(shortname) > -1);
    // make sure the loner port can be updated
    ((LonerDistributionManager) ((InternalDistributedSystem) ds).getDM()).updateLonerPort(100);
}

Example 3 with LonerDistributionManager

use of org.apache.geode.distributed.internal.LonerDistributionManager in project geode by apache.

the class HandShake method handshakeWithServer.

/**
   * Client-side handshake with a Server
   */
public ServerQueueStatus handshakeWithServer(Connection conn, ServerLocation location, byte communicationMode) throws IOException, AuthenticationRequiredException, AuthenticationFailedException, ServerRefusedConnectionException {
    try {
        ServerQueueStatus serverQStatus = null;
        Socket sock = conn.getSocket();
        DataOutputStream dos = new DataOutputStream(sock.getOutputStream());
        final InputStream in = sock.getInputStream();
        DataInputStream dis = new DataInputStream(in);
        DistributedMember member = getIDForSocket(sock);
        // if running in a loner system, use the new port number in the ID to
        // help differentiate from other clients
        DM dm = ((InternalDistributedSystem) this.system).getDistributionManager();
        InternalDistributedMember idm = dm.getDistributionManagerId();
        synchronized (idm) {
            if (idm.getPort() == 0 && dm instanceof LonerDistributionManager) {
                int port = sock.getLocalPort();
                ((LonerDistributionManager) dm).updateLonerPort(port);
                updateProxyID(dm.getDistributionManagerId());
            }
        }
        if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY) {
            this.credentials = getCredentials(member);
        }
        byte intermediateAcceptanceCode = write(dos, dis, communicationMode, REPLY_OK, this.clientReadTimeout, null, this.credentials, member, false);
        String authInit = this.system.getProperties().getProperty(SECURITY_CLIENT_AUTH_INIT);
        if (communicationMode != Acceptor.GATEWAY_TO_GATEWAY && intermediateAcceptanceCode != REPLY_AUTH_NOT_REQUIRED && (authInit != null && authInit.length() != 0)) {
            location.compareAndSetRequiresCredentials(true);
        }
        // Read the acceptance code
        byte acceptanceCode = dis.readByte();
        if (acceptanceCode == (byte) 21 && !(sock instanceof SSLSocket)) {
            // SSL
            throw new AuthenticationRequiredException(LocalizedStrings.HandShake_SERVER_EXPECTING_SSL_CONNECTION.toLocalizedString());
        }
        if (acceptanceCode == REPLY_SERVER_IS_LOCATOR) {
            throw new GemFireConfigException("Improperly configured client detected.  " + "Server at " + location + " is actually a locator.  Use addPoolLocator to configure locators.");
        }
        // Successful handshake for GATEWAY_TO_GATEWAY mode sets the peer version in connection
        if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY && !(acceptanceCode == REPLY_EXCEPTION_AUTHENTICATION_REQUIRED || acceptanceCode == REPLY_EXCEPTION_AUTHENTICATION_FAILED)) {
            short wanSiteVersion = Version.readOrdinal(dis);
            conn.setWanSiteVersion(wanSiteVersion);
            // establish a versioned stream for the other site, if necessary
            if (wanSiteVersion < Version.CURRENT_ORDINAL) {
                dis = new VersionedDataInputStream(dis, Version.fromOrdinalOrCurrent(wanSiteVersion));
            }
        }
        // No need to check for return value since DataInputStream already throws
        // EOFException in case of EOF
        byte epType = dis.readByte();
        int qSize = dis.readInt();
        // Read the server member
        member = readServerMember(dis);
        serverQStatus = new ServerQueueStatus(epType, qSize, member);
        // Read the message (if any)
        readMessage(dis, dos, acceptanceCode, member);
        // DSes with different values of this. It shoule be a member variable.
        if (communicationMode != Acceptor.GATEWAY_TO_GATEWAY && currentClientVersion.compareTo(Version.GFE_61) >= 0) {
            deltaEnabledOnServer = dis.readBoolean();
        }
        // validate that the remote side has a different distributed system id.
        if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY && Version.GFE_66.compareTo(conn.getWanSiteVersion()) <= 0 && currentClientVersion.compareTo(Version.GFE_66) >= 0) {
            int remoteDistributedSystemId = in.read();
            int localDistributedSystemId = ((InternalDistributedSystem) system).getDistributionManager().getDistributedSystemId();
            if (localDistributedSystemId >= 0 && localDistributedSystemId == remoteDistributedSystemId) {
                throw new GatewayConfigurationException("Remote WAN site's distributed system id " + remoteDistributedSystemId + " matches this sites distributed system id " + localDistributedSystemId);
            }
        }
        // Read the PDX registry size from the remote size
        if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY && Version.GFE_80.compareTo(conn.getWanSiteVersion()) <= 0 && currentClientVersion.compareTo(Version.GFE_80) >= 0) {
            int remotePdxSize = dis.readInt();
            serverQStatus.setPdxSize(remotePdxSize);
        }
        return serverQStatus;
    } catch (IOException ex) {
        CancelCriterion stopper = this.system.getCancelCriterion();
        stopper.checkCancelInProgress(null);
        throw ex;
    }
}

Example 4 with LonerDistributionManager

use of org.apache.geode.distributed.internal.LonerDistributionManager in project geode by apache.

the class MemberFunctionExecutionDUnitTest method bug41118.

public static void bug41118() {
    ds = new MemberFunctionExecutionDUnitTest().getSystem();
    assertNotNull(ds);
    ds.disconnect();
    Properties props = new Properties();
    props.setProperty(MCAST_PORT, "0");
    ds = (InternalDistributedSystem) DistributedSystem.connect(props);
    DM dm = ds.getDistributionManager();
    assertEquals("Distributed System is not loner", true, dm instanceof LonerDistributionManager);
    DistributedMember localmember = ds.getDistributedMember();
    Execution memberExcution = null;
    memberExcution = FunctionService.onMember(localmember);
    Execution executor = memberExcution.setArguments("Key");
    try {
        ResultCollector rc = executor.execute(new FunctionAdapter() {

            @Override
            public void execute(FunctionContext context) {
                if (context.getArguments() instanceof String) {
                    context.getResultSender().lastResult("Success");
                } else {
                    context.getResultSender().lastResult("Failure");
                }
            }

            @Override
            public String getId() {
                return getClass().getName();
            }

            @Override
            public boolean hasResult() {
                return true;
            }
        });
        List li = (ArrayList) rc.getResult();
        LogWriterUtils.getLogWriter().info("MemberFunctionExecutionDUnitTest#excuteOnMembers: Result : " + li);
        assertEquals(li.size(), 1);
        for (Object obj : li) {
            assertEquals(obj, "Success");
        }
        ds.disconnect();
    } catch (Exception e) {
        LogWriterUtils.getLogWriter().info("Exception Occurred : " + e.getMessage());
        e.printStackTrace();
        Assert.fail("Test failed", e);
    }
}

Example 5 with LonerDistributionManager

use of org.apache.geode.distributed.internal.LonerDistributionManager in project geode by apache.

the class PRHARedundancyProvider method createBucketAtomically.

/**
   * Creates bucket atomically by creating all the copies to satisfy redundancy. In case all copies
   * can not be created, a PartitionedRegionStorageException is thrown to the user and
   * BucketBackupMessage is sent to the nodes to make copies of a bucket that was only partially
   * created. Other VMs are informed of bucket creation through updates through their
   * {@link BucketAdvisor.BucketProfile}s.
   * 
   * <p>
   * This method is synchronized to enforce a single threaded ordering, allowing for a more accurate
   * picture of bucket distribution in the face of concurrency. See bug 37275.
   * </p>
   * 
   * This method is now slightly misnamed. Another member could be in the process of creating this
   * same bucket at the same time.
   * 
   * @param bucketId Id of the bucket to be created.
   * @param newBucketSize size of the first entry.
   * @param startTime a time stamp prior to calling the method, used to update bucket creation stats
   * @return the primary member for the newly created bucket
   * @throws PartitionedRegionStorageException if required # of buckets can not be created to
   *         satisfy redundancy.
   * @throws PartitionedRegionException if d-lock can not be acquired to create bucket.
   * @throws PartitionOfflineException if persistent data recovery is not complete for a partitioned
   *         region referred to in the query.
   */
public InternalDistributedMember createBucketAtomically(final int bucketId, final int newBucketSize, final long startTime, final boolean finishIncompleteCreation, String partitionName) throws PartitionedRegionStorageException, PartitionedRegionException, PartitionOfflineException {
    final boolean isDebugEnabled = logger.isDebugEnabled();
    prRegion.checkPROffline();
    // If there are insufficient stores throw *before* we try acquiring the
    // (very expensive) bucket lock or the (somewhat expensive) monitor on this
    earlySufficientStoresCheck(partitionName);
    synchronized (this) {
        if (this.prRegion.getCache().isCacheAtShutdownAll()) {
            throw new CacheClosedException("Cache is shutting down");
        }
        if (isDebugEnabled) {
            logger.debug("Starting atomic creation of bucketId={}", this.prRegion.bucketStringForLogs(bucketId));
        }
        Collection<InternalDistributedMember> acceptedMembers = // ArrayList<DataBucketStores>
        new ArrayList<InternalDistributedMember>();
        Set<InternalDistributedMember> excludedMembers = new HashSet<InternalDistributedMember>();
        ArrayListWithClearState<InternalDistributedMember> failedMembers = new ArrayListWithClearState<InternalDistributedMember>();
        final long timeOut = System.currentTimeMillis() + computeTimeout();
        BucketMembershipObserver observer = null;
        boolean needToElectPrimary = true;
        InternalDistributedMember bucketPrimary = null;
        try {
            this.prRegion.checkReadiness();
            Bucket toCreate = this.prRegion.getRegionAdvisor().getBucket(bucketId);
            if (!finishIncompleteCreation) {
                bucketPrimary = this.prRegion.getBucketPrimary(bucketId);
                if (bucketPrimary != null) {
                    if (isDebugEnabled) {
                        logger.debug("during atomic creation, discovered that the primary already exists {} returning early", bucketPrimary);
                    }
                    needToElectPrimary = false;
                    return bucketPrimary;
                }
            }
            observer = new BucketMembershipObserver(toCreate).beginMonitoring();
            // track if insufficient data stores have been
            boolean loggedInsufficentStores = false;
            // detected
            for (; ; ) {
                this.prRegion.checkReadiness();
                if (this.prRegion.getCache().isCacheAtShutdownAll()) {
                    if (isDebugEnabled) {
                        logger.debug("Aborted createBucketAtomically due to ShutdownAll");
                    }
                    throw new CacheClosedException("Cache is shutting down");
                }
                // this.prRegion.getCache().getLogger().config(
                // "DEBUG createBucketAtomically: "
                // + " bucketId=" + this.prRegion.getBucketName(bucketId) +
                // " accepted: " + acceptedMembers +
                // " failed: " + failedMembers);
                long timeLeft = timeOut - System.currentTimeMillis();
                if (timeLeft < 0) {
                    // It took too long.
                    timedOut(this.prRegion, getAllStores(partitionName), acceptedMembers, ALLOCATE_ENOUGH_MEMBERS_TO_HOST_BUCKET.toLocalizedString(), computeTimeout());
                // NOTREACHED
                }
                if (isDebugEnabled) {
                    logger.debug("createBucketAtomically: have {} ms left to finish this", timeLeft);
                }
                // Always go back to the advisor, see if any fresh data stores are
                // present.
                Set<InternalDistributedMember> allStores = getAllStores(partitionName);
                loggedInsufficentStores = checkSufficientStores(allStores, loggedInsufficentStores);
                InternalDistributedMember candidate = createBucketInstance(bucketId, newBucketSize, excludedMembers, acceptedMembers, failedMembers, timeOut, allStores);
                if (candidate != null) {
                    if (this.prRegion.getDistributionManager().enforceUniqueZone()) {
                        // enforceUniqueZone property has no effect for a loner. Fix for defect #47181
                        if (!(this.prRegion.getDistributionManager() instanceof LonerDistributionManager)) {
                            Set<InternalDistributedMember> exm = getBuddyMembersInZone(candidate, allStores);
                            exm.remove(candidate);
                            exm.removeAll(acceptedMembers);
                            excludedMembers.addAll(exm);
                        } else {
                            // log a warning if Loner
                            logger.warn(LocalizedMessage.create(LocalizedStrings.GemFireCache_ENFORCE_UNIQUE_HOST_NOT_APPLICABLE_FOR_LONER));
                        }
                    }
                }
                // Get an updated list of bucket owners, which should include
                // buckets created concurrently with this createBucketAtomically call
                acceptedMembers = prRegion.getRegionAdvisor().getBucketOwners(bucketId);
                if (isDebugEnabled) {
                    logger.debug("Accepted members: {}", acceptedMembers);
                }
                // the candidate has accepted
                if (bucketPrimary == null && acceptedMembers.contains(candidate)) {
                    bucketPrimary = candidate;
                }
                // prune out the stores that have left
                verifyBucketNodes(excludedMembers, partitionName);
                // Note - we used to wait for the created bucket to become primary here
                // if this is a colocated region. We no longer need to do that, because
                // the EndBucketMessage is sent out after bucket creation completes to
                // select the primary.
                // Have we exhausted all candidates?
                final int potentialCandidateCount = (allStores.size() - (excludedMembers.size() + acceptedMembers.size() + failedMembers.size()));
                // Determining exhausted members competes with bucket balancing; it's
                // important to re-visit all failed members since "failed" set may
                // contain datastores which at the moment are imbalanced, but yet could
                // be candidates. If the failed members list is empty, its expected
                // that the next iteration clears the (already empty) list.
                final boolean exhaustedPotentialCandidates = failedMembers.wasCleared() && potentialCandidateCount <= 0;
                final boolean redundancySatisfied = acceptedMembers.size() > this.prRegion.getRedundantCopies();
                final boolean bucketNotCreated = acceptedMembers.size() == 0;
                if (isDebugEnabled) {
                    logger.debug("potentialCandidateCount={}, exhaustedPotentialCandidates={}, redundancySatisfied={}, bucketNotCreated={}", potentialCandidateCount, exhaustedPotentialCandidates, redundancySatisfied, bucketNotCreated);
                }
                if (bucketNotCreated) {
                    // if we haven't managed to create the bucket on any nodes, retry.
                    continue;
                }
                if (exhaustedPotentialCandidates && !redundancySatisfied) {
                    insufficientStores(allStores, acceptedMembers, true);
                }
                // Fix for bug 39283
                if (redundancySatisfied || exhaustedPotentialCandidates) {
                    // Tell one of the members to become primary.
                    // The rest of the members will be allowed to
                    // volunteer for primary.
                    endBucketCreation(bucketId, acceptedMembers, bucketPrimary, partitionName);
                    final int expectedRemoteHosts = acceptedMembers.size() - (acceptedMembers.contains(this.prRegion.getMyId()) ? 1 : 0);
                    boolean interrupted = Thread.interrupted();
                    try {
                        BucketMembershipObserverResults results = observer.waitForOwnersGetPrimary(expectedRemoteHosts, acceptedMembers, partitionName);
                        if (results.problematicDeparture) {
                            // BZZZT! Member left. Start over.
                            continue;
                        }
                        bucketPrimary = results.primary;
                    } catch (InterruptedException e) {
                        interrupted = true;
                        this.prRegion.getCancelCriterion().checkCancelInProgress(e);
                    } finally {
                        if (interrupted) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    needToElectPrimary = false;
                    return bucketPrimary;
                }
            // almost done
            }
        // for
        } catch (CancelException e) {
            // Fix for 43544 - We don't need to elect a primary
            // if the cache was closed. The other members will
            // take care of it. This ensures we don't compromise
            // redundancy.
            needToElectPrimary = false;
            throw e;
        } catch (RegionDestroyedException e) {
            // Fix for 43544 - We don't need to elect a primary
            // if the region was destroyed. The other members will
            // take care of it. This ensures we don't compromise
            // redundancy.
            needToElectPrimary = false;
            throw e;
        } catch (PartitionOfflineException e) {
            throw e;
        } catch (RuntimeException e) {
            if (isDebugEnabled) {
                logger.debug("Unable to create new bucket {}: {}", bucketId, e.getMessage(), e);
            }
            // than reattempting on other nodes?
            if (!finishIncompleteCreation) {
                cleanUpBucket(bucketId);
            }
            throw e;
        } finally {
            if (observer != null) {
                observer.stopMonitoring();
            }
            // Try to make sure everyone that created the bucket can volunteer for primary
            if (needToElectPrimary) {
                try {
                    endBucketCreation(bucketId, prRegion.getRegionAdvisor().getBucketOwners(bucketId), bucketPrimary, partitionName);
                } catch (Exception e) {
                    // if region is going down, then no warning level logs
                    if (e instanceof CancelException || e instanceof CacheClosedException || (prRegion.getCancelCriterion().isCancelInProgress())) {
                        logger.debug("Exception trying choose a primary after bucket creation failure", e);
                    } else {
                        logger.warn("Exception trying choose a primary after bucket creation failure", e);
                    }
                }
            }
        }
    }
// synchronized(this)
}