Examples with InternalRegionArguments org.apache.geode.internal.cache.InternalRegionArguments used on opensource projects

Example 16 with InternalRegionArguments

use of org.apache.geode.internal.cache.InternalRegionArguments in project geode by apache.

the class TXDistributedDUnitTest method testRemoteCommitFailure.

@Ignore("TODO: Disabled for #51260")
@Test
public void testRemoteCommitFailure() throws Exception {
    try {
        disconnectAllFromDS();
        final String rgnName1 = getUniqueName() + "_1";
        final String rgnName2 = getUniqueName() + "_2";
        final String diskStoreName = getUniqueName() + "_store";
        Host host = Host.getHost(0);
        VM origin = host.getVM(0);
        VM trouble1 = host.getVM(1);
        VM trouble2 = host.getVM(2);
        VM noTrouble = host.getVM(3);
        CacheSerializableRunnable initRegions = new CacheSerializableRunnable("Initialize no trouble regions") {

            @Override
            public void run2() {
                getCache().createDiskStoreFactory().setDiskDirs(getDiskDirs()).create(diskStoreName);
                TXManagerImpl.ALLOW_PERSISTENT_TRANSACTIONS = true;
                AttributesFactory af = new AttributesFactory();
                af.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
                af.setScope(Scope.DISTRIBUTED_ACK);
                af.setDiskStoreName(diskStoreName);
                getCache().createRegion(rgnName1, af.create());
                getCache().createRegion(rgnName2, af.create());
            }
        };
        origin.invoke(initRegions);
        noTrouble.invoke(initRegions);
        SerializableRunnable initTroulbeRegions = new CacheSerializableRunnable("Initialize regions that cause trouble") {

            @Override
            public void run2() {
                GemFireCacheImpl gfc = (GemFireCacheImpl) getCache();
                InternalRegionArguments ira = new InternalRegionArguments().setTestCallable(new TXTroubleMaker());
                try {
                    getCache().createDiskStoreFactory().setDiskDirs(getDiskDirs()).create(diskStoreName);
                    TXManagerImpl.ALLOW_PERSISTENT_TRANSACTIONS = true;
                    AttributesFactory af = new AttributesFactory();
                    af.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
                    af.setScope(Scope.DISTRIBUTED_ACK);
                    af.setDiskStoreName(diskStoreName);
                    gfc.createVMRegion(rgnName1, af.create(), ira);
                    gfc.createVMRegion(rgnName2, af.create(), ira);
                    gfc.getInternalDistributedSystem().addResourceListener(new ShutdownListener());
                } catch (IOException ioe) {
                    fail(ioe.toString());
                } catch (TimeoutException e) {
                    fail(e.toString());
                } catch (ClassNotFoundException e) {
                    fail(e.toString());
                }
            }
        };
        trouble1.invoke(initTroulbeRegions);
        trouble2.invoke(initTroulbeRegions);
        SerializableRunnable doTransaction = new CacheSerializableRunnable("Run failing transaction") {

            @Override
            public void run2() {
                Cache c = getCache();
                Region r1 = c.getRegion(rgnName1);
                assertNotNull(r1);
                Region r2 = c.getRegion(rgnName2);
                assertNotNull(r2);
                CacheTransactionManager txmgr = c.getCacheTransactionManager();
                txmgr.begin();
                r1.put("k1", "k1");
                r1.put("k2", "k2");
                r1.put(TROUBLE_KEY, TROUBLE_KEY);
                r2.put("k1", "k1");
                r2.put("k2", "k2");
                r2.put(TROUBLE_KEY, TROUBLE_KEY);
                try {
                    txmgr.commit();
                    fail("Expected an tx incomplete exception");
                } catch (CommitIncompleteException yay) {
                    String msg = yay.getMessage();
                    // getLogWriter().info("failing exception", yay);
                    // Each region on a trouble VM should be mentioned (two regions per trouble VM)
                    int ind = 0, match = 0;
                    while ((ind = msg.indexOf(rgnName1, ind)) >= 0) {
                        ind++;
                        match++;
                    }
                    assertEquals(2, match);
                    ind = match = 0;
                    while ((ind = msg.indexOf(rgnName2, ind)) >= 0) {
                        ind++;
                        match++;
                    }
                    assertEquals(2, match);
                    // DiskAccessExcpetions should be mentioned four times
                    ind = match = 0;
                    while ((ind = msg.indexOf(DiskAccessException.class.getName(), ind)) >= 0) {
                        ind++;
                        match++;
                    }
                    assertEquals(4, match);
                }
            }
        };
        IgnoredException ee = null;
        try {
            ee = IgnoredException.addIgnoredException(DiskAccessException.class.getName() + "|" + CommitIncompleteException.class.getName() + "|" + CommitReplyException.class.getName());
            origin.invoke(doTransaction);
        } finally {
            if (ee != null)
                ee.remove();
        }
        SerializableCallable allowCacheToShutdown = new SerializableCallable() {

            @Override
            public Object call() throws Exception {
                GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
                List<ResourceEventsListener> listeners = cache.getInternalDistributedSystem().getResourceListeners();
                for (ResourceEventsListener l : listeners) {
                    if (l instanceof ShutdownListener) {
                        ShutdownListener shutListener = (ShutdownListener) l;
                        shutListener.unblockShutdown();
                    }
                }
                return null;
            }
        };
        trouble1.invoke(allowCacheToShutdown);
        trouble2.invoke(allowCacheToShutdown);
        // Assert proper content on failing VMs
        SerializableRunnable assertTroubledContent = new CacheSerializableRunnable("Assert partail commit data") {

            @Override
            public void run2() {
                final Cache c = getCache();
                Wait.waitForCriterion(new WaitCriterion() {

                    @Override
                    public boolean done() {
                        return c.getRegion(rgnName1) == null;
                    }

                    @Override
                    public String description() {
                        return null;
                    }
                }, 30000, 1000, true);
                Region r2 = c.getRegion(rgnName2);
                assertNull(r2);
            }
        };
        trouble1.invoke(assertTroubledContent);
        trouble2.invoke(assertTroubledContent);
        // Assert proper content on successful VMs
        SerializableRunnable assertSuccessfulContent = new CacheSerializableRunnable("Assert complete commit of data on successful VMs") {

            @Override
            public void run2() {
                Cache c = getCache();
                {
                    Region r1 = c.getRegion(rgnName1);
                    assertNotNull(r1);
                    assertEquals("k1", r1.getEntry("k1").getValue());
                    assertEquals("k2", r1.getEntry("k2").getValue());
                    assertEquals(TROUBLE_KEY, r1.getEntry(TROUBLE_KEY).getValue());
                }
                {
                    Region r2 = c.getRegion(rgnName2);
                    assertNotNull(r2);
                    assertEquals("k1", r2.getEntry("k1").getValue());
                    assertEquals("k2", r2.getEntry("k2").getValue());
                    assertEquals(TROUBLE_KEY, r2.getEntry(TROUBLE_KEY).getValue());
                }
            }
        };
        noTrouble.invoke(assertSuccessfulContent);
        // Assert no content on originating VM
        SerializableRunnable assertNoContent = new CacheSerializableRunnable("Assert data survives on origin VM") {

            @Override
            public void run2() {
                Cache c = getCache();
                {
                    Region r1 = c.getRegion(rgnName1);
                    assertNotNull(r1);
                    assertNotNull(r1.getEntry("k1"));
                    assertNotNull(r1.getEntry("k2"));
                    assertNotNull(r1.getEntry(TROUBLE_KEY));
                }
                {
                    Region r2 = c.getRegion(rgnName2);
                    assertNotNull(r2);
                    assertNotNull(r2.getEntry("k1"));
                    assertNotNull(r2.getEntry("k2"));
                    assertNotNull(r2.getEntry(TROUBLE_KEY));
                }
            }
        };
        origin.invoke(assertNoContent);
    } finally {
        Invoke.invokeInEveryVM(new SerializableCallable() {

            @Override
            public Object call() throws Exception {
                TXManagerImpl.ALLOW_PERSISTENT_TRANSACTIONS = false;
                return null;
            }
        });
    }
}

Example 17 with InternalRegionArguments

use of org.apache.geode.internal.cache.InternalRegionArguments in project geode by apache.

the class ClusterConfigurationService method getConfigurationRegion.

/**
   * Gets the region containing the shared configuration data. The region is created , if it does
   * not exist already. Note : this could block if this locator contains stale persistent
   * configuration data.
   * 
   * @return {@link Region} ConfigurationRegion, this should never be null
   */
private Region<String, Configuration> getConfigurationRegion() {
    Region<String, Configuration> configRegion = this.cache.getRegion(CONFIG_REGION_NAME);
    try {
        if (configRegion == null) {
            File diskDir = new File(this.configDiskDirPath);
            if (!diskDir.exists()) {
                if (!diskDir.mkdirs()) {
                    // TODO: throw caught by containing try statement
                    throw new IOException("Cannot create directory at " + this.configDiskDirPath);
                }
            }
            File[] diskDirs = { diskDir };
            this.cache.createDiskStoreFactory().setDiskDirs(diskDirs).setAutoCompact(true).setMaxOplogSize(10).create(CLUSTER_CONFIG_DISK_STORE_NAME);
            AttributesFactory<String, Configuration> regionAttrsFactory = new AttributesFactory<>();
            regionAttrsFactory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
            regionAttrsFactory.setCacheListener(new ConfigurationChangeListener(this));
            regionAttrsFactory.setDiskStoreName(CLUSTER_CONFIG_DISK_STORE_NAME);
            regionAttrsFactory.setScope(Scope.DISTRIBUTED_ACK);
            InternalRegionArguments internalArgs = new InternalRegionArguments();
            internalArgs.setIsUsedForMetaRegion(true);
            internalArgs.setMetaRegionWithTransactions(false);
            configRegion = this.cache.createVMRegion(CONFIG_REGION_NAME, regionAttrsFactory.create(), internalArgs);
        }
    } catch (CancelException e) {
        if (configRegion == null) {
            this.status.set(SharedConfigurationStatus.STOPPED);
        }
        // CONFIG: don't rethrow as Exception, keep it a subclass of CancelException
        throw e;
    } catch (Exception e) {
        if (configRegion == null) {
            this.status.set(SharedConfigurationStatus.STOPPED);
        }
        throw new RuntimeException("Error occurred while initializing cluster configuration", e);
    }
    return configRegion;
}

Example 18 with InternalRegionArguments

use of org.apache.geode.internal.cache.InternalRegionArguments in project geode by apache.

the class LocalManager method startLocalManagement.

/**
   * Managed Node side resources are created
   * 
   * Management Region : its a Replicated NO_ACK region Notification Region : its a Replicated Proxy
   * NO_ACK region
   */
private void startLocalManagement(Map<ObjectName, FederationComponent> federatedComponentMap) {
    synchronized (this) {
        if (repo.getLocalMonitoringRegion() != null) {
            return;
        } else {
            ThreadFactory tf = new ThreadFactory() {

                public Thread newThread(final Runnable command) {
                    final Runnable r = new Runnable() {

                        public void run() {
                            command.run();
                        }
                    };
                    final ThreadGroup group = LoggingThreadGroup.createThreadGroup(ManagementStrings.MANAGEMENT_TASK_THREAD_GROUP.toLocalizedString(), logger);
                    Thread thread = new Thread(group, r, ManagementStrings.MANAGEMENT_TASK.toLocalizedString());
                    thread.setDaemon(true);
                    return thread;
                }
            };
            singleThreadFederationScheduler = Executors.newSingleThreadScheduledExecutor(tf);
            if (logger.isDebugEnabled()) {
                logger.debug("Creating  Management Region :");
            }
            /*
         * Sharing the same Internal Argument for both notification region and monitoring region
         */
            InternalRegionArguments internalArgs = new InternalRegionArguments();
            internalArgs.setIsUsedForMetaRegion(true);
            // Create anonymous stats holder for Management Regions
            final HasCachePerfStats monitoringRegionStats = new HasCachePerfStats() {

                public CachePerfStats getCachePerfStats() {
                    return new CachePerfStats(cache.getDistributedSystem(), "managementRegionStats");
                }
            };
            internalArgs.setCachePerfStatsHolder(monitoringRegionStats);
            AttributesFactory<String, Object> monitorRegionAttributeFactory = new AttributesFactory<String, Object>();
            monitorRegionAttributeFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
            monitorRegionAttributeFactory.setDataPolicy(DataPolicy.REPLICATE);
            monitorRegionAttributeFactory.setConcurrencyChecksEnabled(false);
            MonitoringRegionCacheListener localListener = new MonitoringRegionCacheListener(service);
            monitorRegionAttributeFactory.addCacheListener(localListener);
            RegionAttributes<String, Object> monitoringRegionAttrs = monitorRegionAttributeFactory.create();
            AttributesFactory<NotificationKey, Notification> notificationRegionAttributeFactory = new AttributesFactory<NotificationKey, Notification>();
            notificationRegionAttributeFactory.setScope(Scope.DISTRIBUTED_NO_ACK);
            notificationRegionAttributeFactory.setDataPolicy(DataPolicy.EMPTY);
            notificationRegionAttributeFactory.setConcurrencyChecksEnabled(false);
            RegionAttributes<NotificationKey, Notification> notifRegionAttrs = notificationRegionAttributeFactory.create();
            String appender = MBeanJMXAdapter.getUniqueIDForMember(cache.getDistributedSystem().getDistributedMember());
            boolean monitoringRegionCreated = false;
            boolean notifRegionCreated = false;
            try {
                repo.setLocalMonitoringRegion(cache.createVMRegion(ManagementConstants.MONITORING_REGION + "_" + appender, monitoringRegionAttrs, internalArgs));
                monitoringRegionCreated = true;
            } catch (TimeoutException e) {
                throw new ManagementException(e);
            } catch (RegionExistsException e) {
                throw new ManagementException(e);
            } catch (IOException e) {
                throw new ManagementException(e);
            } catch (ClassNotFoundException e) {
                throw new ManagementException(e);
            }
            try {
                repo.setLocalNotificationRegion(cache.createVMRegion(ManagementConstants.NOTIFICATION_REGION + "_" + appender, notifRegionAttrs, internalArgs));
                notifRegionCreated = true;
            } catch (TimeoutException e) {
                throw new ManagementException(e);
            } catch (RegionExistsException e) {
                throw new ManagementException(e);
            } catch (IOException e) {
                throw new ManagementException(e);
            } catch (ClassNotFoundException e) {
                throw new ManagementException(e);
            } finally {
                if (!notifRegionCreated && monitoringRegionCreated) {
                    repo.getLocalMonitoringRegion().localDestroyRegion();
                }
            }
            managementTask = new ManagementTask(federatedComponentMap);
            // call run to get us initialized immediately with a sync call
            managementTask.run();
            // All local resources are created for the ManagementTask
            // Now Management tasks can proceed.
            int updateRate = cache.getInternalDistributedSystem().getConfig().getJmxManagerUpdateRate();
            singleThreadFederationScheduler.scheduleAtFixedRate(managementTask, updateRate, updateRate, TimeUnit.MILLISECONDS);
            if (logger.isDebugEnabled()) {
                logger.debug("Management Region created with Name : {}", repo.getLocalMonitoringRegion().getName());
                logger.debug("Notification Region created with Name : {}", repo.getLocalNotificationRegion().getName());
            }
        }
    }
}

Example 19 with InternalRegionArguments

use of org.apache.geode.internal.cache.InternalRegionArguments in project geode by apache.

the class PeerTypeRegistration method initialize.

public void initialize() {
    AttributesFactory<Object, Object> factory = new AttributesFactory<Object, Object>();
    factory.setScope(Scope.DISTRIBUTED_ACK);
    if (cache.getPdxPersistent()) {
        if (cache.getCacheConfig().pdxDiskStoreUserSet) {
            factory.setDiskStoreName(cache.getPdxDiskStore());
        } else {
            factory.setDiskStoreName(cache.getOrCreateDefaultDiskStore().getName());
        }
        factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
    } else {
        factory.setDataPolicy(DataPolicy.REPLICATE);
    }
    // Add a listener that makes sure that if anyone in the DS is using PDX
    // Our PDX configuration is valid for this member. This is important if
    // we are the gateway, we need to validate that we have a distributed system
    // id.
    factory.addCacheListener(new CacheListenerAdapter<Object, Object>() {

        @Override
        public void afterCreate(EntryEvent<Object, Object> event) {
            verifyConfiguration();
            // update a local map with the pdxtypes registered
            Object value = event.getNewValue();
            if (value instanceof PdxType) {
                updateClassToTypeMap((PdxType) value);
            }
        }
    });
    factory.setCacheWriter(new CacheWriterAdapter<Object, Object>() {

        @Override
        public void beforeCreate(EntryEvent<Object, Object> event) throws CacheWriterException {
            Object newValue = event.getNewValue();
            if (newValue instanceof PdxType) {
                logger.info("Adding new type: {}", ((PdxType) event.getNewValue()).toFormattedString());
            } else {
                logger.info("Adding new type: {} {}", event.getKey(), ((EnumInfo) newValue).toFormattedString());
            }
        }

        @Override
        public void beforeUpdate(EntryEvent<Object, Object> event) throws CacheWriterException {
            if (!event.getRegion().get(event.getKey()).equals(event.getNewValue())) {
                PdxRegistryMismatchException ex = new PdxRegistryMismatchException("Trying to add a PDXType with the same id as an existing PDX type. id=" + event.getKey() + ", existing pdx type " + event.getOldValue() + ", new type " + event.getNewValue());
                throw new CacheWriterException(ex);
            }
        }
    });
    RegionAttributes<Object, Object> regionAttrs = factory.create();
    InternalRegionArguments internalArgs = new InternalRegionArguments();
    internalArgs.setIsUsedForMetaRegion(true);
    internalArgs.setMetaRegionWithTransactions(true);
    try {
        this.idToType = cache.createVMRegion(REGION_NAME, regionAttrs, internalArgs);
    } catch (IOException ex) {
        throw new PdxInitializationException("Could not create pdx registry", ex);
    } catch (TimeoutException ex) {
        throw new PdxInitializationException("Could not create pdx registry", ex);
    } catch (RegionExistsException ex) {
        throw new PdxInitializationException("Could not create pdx registry", ex);
    } catch (ClassNotFoundException ex) {
        throw new PdxInitializationException("Could not create pdx registry", ex);
    }
    // And send those types to any existing gateways.
    if (!getIdToType().isEmpty()) {
        verifyConfiguration();
    }
}

Example 20 with InternalRegionArguments

use of org.apache.geode.internal.cache.InternalRegionArguments in project geode by apache.

the class PersistentRecoveryOrderDUnitTest method createInternalPersistentRegionAsync.

protected AsyncInvocation createInternalPersistentRegionAsync(final VM vm) {
    SerializableRunnable createRegion = new SerializableRunnable("Create persistent region") {

        public void run() {
            Cache cache = getCache();
            DiskStoreFactory dsf = cache.createDiskStoreFactory();
            File dir = getDiskDirForVM(vm);
            dir.mkdirs();
            dsf.setDiskDirs(new File[] { dir });
            dsf.setMaxOplogSize(1);
            DiskStore ds = dsf.create(REGION_NAME);
            InternalRegionArguments internalArgs = new InternalRegionArguments();
            internalArgs.setIsUsedForMetaRegion(true);
            internalArgs.setMetaRegionWithTransactions(true);
            AttributesFactory rf = new AttributesFactory();
            rf.setDiskStoreName(ds.getName());
            rf.setDiskSynchronous(true);
            rf.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
            rf.setScope(Scope.DISTRIBUTED_ACK);
            try {
                ((GemFireCacheImpl) cache).createVMRegion(REGION_NAME, rf.create(), internalArgs);
            } catch (ClassNotFoundException e) {
                Assert.fail("error", e);
            } catch (IOException e) {
                Assert.fail("error", e);
            }
        }
    };
    return vm.invokeAsync(createRegion);
}