You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by je...@apache.org on 2016/02/25 21:27:29 UTC
[41/50] [abbrv] incubator-geode git commit: Merge branch 'develop'
into feature/GEODE-17
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5c01d5f4/geode-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/CreateAlterDestroyRegionCommands.java
----------------------------------------------------------------------
diff --cc geode-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/CreateAlterDestroyRegionCommands.java
index 0000000,bf1fdf0..6286bdd
mode 000000,100644..100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/CreateAlterDestroyRegionCommands.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/management/internal/cli/commands/CreateAlterDestroyRegionCommands.java
@@@ -1,0 -1,1200 +1,1206 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package com.gemstone.gemfire.management.internal.cli.commands;
+
+ import java.lang.reflect.Array;
+ import java.text.MessageFormat;
+ import java.util.ArrayList;
+ import java.util.Arrays;
+ import java.util.Collections;
+ import java.util.HashSet;
+ import java.util.Iterator;
+ import java.util.List;
+ import java.util.Map;
+ import java.util.Map.Entry;
+ import java.util.Set;
+ import java.util.TreeSet;
+ import java.util.regex.Pattern;
+
+ import javax.management.MBeanServer;
+ import javax.management.MalformedObjectNameException;
+ import javax.management.ObjectName;
+
+ import org.springframework.shell.core.annotation.CliAvailabilityIndicator;
+ import org.springframework.shell.core.annotation.CliCommand;
+ import org.springframework.shell.core.annotation.CliOption;
+
+ import com.gemstone.gemfire.LogWriter;
+ import com.gemstone.gemfire.cache.Cache;
+ import com.gemstone.gemfire.cache.CacheFactory;
+ import com.gemstone.gemfire.cache.DataPolicy;
+ import com.gemstone.gemfire.cache.ExpirationAttributes;
+ import com.gemstone.gemfire.cache.Region;
+ import com.gemstone.gemfire.cache.RegionAttributes;
+ import com.gemstone.gemfire.cache.RegionShortcut;
+ import com.gemstone.gemfire.cache.Scope;
+ import com.gemstone.gemfire.cache.execute.ResultCollector;
+ import com.gemstone.gemfire.compression.Compressor;
+ import com.gemstone.gemfire.distributed.DistributedMember;
+ import com.gemstone.gemfire.distributed.internal.DistributionManager;
+ import com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember;
+ import com.gemstone.gemfire.internal.ClassPathLoader;
+ import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
+ import com.gemstone.gemfire.internal.cache.xmlcache.CacheXml;
+ import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
+ import com.gemstone.gemfire.internal.lang.StringUtils;
+ import com.gemstone.gemfire.management.DistributedRegionMXBean;
+ import com.gemstone.gemfire.management.DistributedSystemMXBean;
+ import com.gemstone.gemfire.management.ManagementService;
+ import com.gemstone.gemfire.management.RegionAttributesData;
+ import com.gemstone.gemfire.management.RegionMXBean;
+ import com.gemstone.gemfire.management.cli.CliMetaData;
+ import com.gemstone.gemfire.management.cli.ConverterHint;
+ import com.gemstone.gemfire.management.cli.Result;
+ import com.gemstone.gemfire.management.cli.Result.Status;
+ import com.gemstone.gemfire.management.internal.MBeanJMXAdapter;
+ import com.gemstone.gemfire.management.internal.cli.CliUtil;
+ import com.gemstone.gemfire.management.internal.cli.LogWrapper;
+ import com.gemstone.gemfire.management.internal.cli.functions.CliFunctionResult;
+ import com.gemstone.gemfire.management.internal.cli.functions.FetchRegionAttributesFunction;
+ import com.gemstone.gemfire.management.internal.cli.functions.FetchRegionAttributesFunction.FetchRegionAttributesFunctionResult;
+ import com.gemstone.gemfire.management.internal.cli.functions.RegionAlterFunction;
+ import com.gemstone.gemfire.management.internal.cli.functions.RegionCreateFunction;
+ import com.gemstone.gemfire.management.internal.cli.functions.RegionDestroyFunction;
+ import com.gemstone.gemfire.management.internal.cli.functions.RegionFunctionArgs;
+ import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings;
+ import com.gemstone.gemfire.management.internal.cli.result.CommandResultException;
+ import com.gemstone.gemfire.management.internal.cli.result.ResultBuilder;
+ import com.gemstone.gemfire.management.internal.cli.result.TabularResultData;
+ import com.gemstone.gemfire.management.internal.cli.util.RegionPath;
+ import com.gemstone.gemfire.management.internal.configuration.SharedConfigurationWriter;
+ import com.gemstone.gemfire.management.internal.configuration.domain.XmlEntity;
++import com.gemstone.gemfire.management.internal.security.Resource;
++import com.gemstone.gemfire.management.internal.security.ResourceConstants;
++import com.gemstone.gemfire.management.internal.security.ResourceOperation;
+
+ /**
+ *
+ * @author Abhishek Chaudhari
+ * @since 7.0
+ */
+ public class CreateAlterDestroyRegionCommands extends AbstractCommandsSupport {
+ public static final Set<RegionShortcut> PERSISTENT_OVERFLOW_SHORTCUTS = new TreeSet<RegionShortcut>();
+
+ static {
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.PARTITION_PERSISTENT);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.PARTITION_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.PARTITION_REDUNDANT_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.PARTITION_PERSISTENT_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.REPLICATE_PERSISTENT);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.REPLICATE_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.REPLICATE_PERSISTENT_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.LOCAL_PERSISTENT);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.LOCAL_OVERFLOW);
+ PERSISTENT_OVERFLOW_SHORTCUTS.add(RegionShortcut.LOCAL_PERSISTENT_OVERFLOW);
+ }
+
+ @CliCommand (value = CliStrings.CREATE_REGION, help = CliStrings.CREATE_REGION__HELP)
+ @CliMetaData (relatedTopic = CliStrings.TOPIC_GEMFIRE_REGION, writesToSharedConfiguration = true)
++ @ResourceOperation(resource = Resource.DISTRIBUTED_SYSTEM, operation= ResourceConstants.CREATE_REGION)
+ public Result createRegion(
+ @CliOption (key = CliStrings.CREATE_REGION__REGION,
+ mandatory = true,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__REGION__HELP)
+ String regionPath,
+ @CliOption (key = CliStrings.CREATE_REGION__REGIONSHORTCUT,
+ mandatory = false,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__REGIONSHORTCUT__HELP)
+ RegionShortcut regionShortcut,
+ @CliOption (key = CliStrings.CREATE_REGION__USEATTRIBUTESFROM,
+ optionContext = ConverterHint.REGIONPATH,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__USEATTRIBUTESFROM__HELP)
+ String useAttributesFrom,
+ @CliOption (key = CliStrings.CREATE_REGION__GROUP,
+ optionContext = ConverterHint.MEMBERGROUP,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__GROUP__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] groups,
+ @CliOption (key = CliStrings.CREATE_REGION__SKIPIFEXISTS,
+ unspecifiedDefaultValue = "true",
+ specifiedDefaultValue = "true",
+ help = CliStrings.CREATE_REGION__SKIPIFEXISTS__HELP)
+ boolean skipIfExists,
+
+ // the following should all be in alphabetical order according to
+ // their key string
+ @CliOption (key = CliStrings.CREATE_REGION__ASYNCEVENTQUEUEID,
+ help = CliStrings.CREATE_REGION__ASYNCEVENTQUEUEID__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] asyncEventQueueIds,
+ @CliOption (key = CliStrings.CREATE_REGION__CACHELISTENER,
+ help = CliStrings.CREATE_REGION__CACHELISTENER__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] cacheListener,
+ @CliOption (key = CliStrings.CREATE_REGION__CACHELOADER,
+ help = CliStrings.CREATE_REGION__CACHELOADER__HELP)
+ String cacheLoader,
+ @CliOption (key = CliStrings.CREATE_REGION__CACHEWRITER,
+ help = CliStrings.CREATE_REGION__CACHEWRITER__HELP)
+ String cacheWriter,
+ @CliOption (key = CliStrings.CREATE_REGION__COLOCATEDWITH,
+ optionContext = ConverterHint.REGIONPATH,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__COLOCATEDWITH__HELP)
+ String prColocatedWith,
+ @CliOption (key = CliStrings.CREATE_REGION__COMPRESSOR,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__COMPRESSOR__HELP)
+ String compressor,
+ @CliOption (key = CliStrings.CREATE_REGION__CONCURRENCYLEVEL,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__CONCURRENCYLEVEL__HELP)
+ Integer concurrencyLevel,
+ @CliOption (key = CliStrings.CREATE_REGION__DISKSTORE,
+ help = CliStrings.CREATE_REGION__DISKSTORE__HELP)
+ String diskStore,
+ @CliOption (key = CliStrings.CREATE_REGION__ENABLEASYNCCONFLATION,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__ENABLEASYNCCONFLATION__HELP)
+ Boolean enableAsyncConflation,
+ @CliOption (key = CliStrings.CREATE_REGION__CLONINGENABLED,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__CLONINGENABLED__HELP)
+ Boolean cloningEnabled,
+ @CliOption (key = CliStrings.CREATE_REGION__CONCURRENCYCHECKSENABLED,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__CONCURRENCYCHECKSENABLED__HELP)
+ Boolean concurrencyChecksEnabled,
+ @CliOption (key = CliStrings.CREATE_REGION__MULTICASTENABLED,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__MULTICASTENABLED__HELP)
+ Boolean mcastEnabled,
+ @CliOption (key = CliStrings.CREATE_REGION__STATISTICSENABLED,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__STATISTICSENABLED__HELP)
+ Boolean statisticsEnabled,
+ @CliOption (key = CliStrings.CREATE_REGION__ENABLESUBSCRIPTIONCONFLATION,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__ENABLESUBSCRIPTIONCONFLATION__HELP)
+ Boolean enableSubscriptionConflation,
+ @CliOption (key = CliStrings.CREATE_REGION__DISKSYNCHRONOUS,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__DISKSYNCHRONOUS__HELP)
+ Boolean diskSynchronous,
+ @CliOption (key = CliStrings.CREATE_REGION__ENTRYEXPIRATIONIDLETIME,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__ENTRYEXPIRATIONIDLETIME__HELP)
+ Integer entryExpirationIdleTime,
+ @CliOption (key = CliStrings.CREATE_REGION__ENTRYEXPIRATIONIDLETIMEACTION,
+ help = CliStrings.CREATE_REGION__ENTRYEXPIRATIONIDLETIMEACTION__HELP)
+ String entryExpirationIdleTimeAction,
+ @CliOption (key = CliStrings.CREATE_REGION__ENTRYEXPIRATIONTIMETOLIVE,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__ENTRYEXPIRATIONTIMETOLIVE__HELP)
+ Integer entryExpirationTTL,
+ @CliOption (key = CliStrings.CREATE_REGION__ENTRYEXPIRATIONTTLACTION,
+ help = CliStrings.CREATE_REGION__ENTRYEXPIRATIONTTLACTION__HELP)
+ String entryExpirationTTLAction,
+ @CliOption (key = CliStrings.CREATE_REGION__GATEWAYSENDERID,
+ help = CliStrings.CREATE_REGION__GATEWAYSENDERID__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] gatewaySenderIds,
+ @CliOption (key = CliStrings.CREATE_REGION__KEYCONSTRAINT,
+ help = CliStrings.CREATE_REGION__KEYCONSTRAINT__HELP)
+ String keyConstraint,
+ @CliOption (key = CliStrings.CREATE_REGION__LOCALMAXMEMORY,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__LOCALMAXMEMORY__HELP)
+ Integer prLocalMaxMemory,
+ @CliOption (key = CliStrings.CREATE_REGION__OFF_HEAP,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "true",
+ help = CliStrings.CREATE_REGION__OFF_HEAP__HELP)
+ Boolean offHeap,
+ @CliOption (key = CliStrings.CREATE_REGION__REGIONEXPIRATIONIDLETIME,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__REGIONEXPIRATIONIDLETIME__HELP)
+ Integer regionExpirationIdleTime,
+ @CliOption (key = CliStrings.CREATE_REGION__REGIONEXPIRATIONIDLETIMEACTION,
+ help = CliStrings.CREATE_REGION__REGIONEXPIRATIONIDLETIMEACTION__HELP)
+ String regionExpirationIdleTimeAction,
+ @CliOption (key = CliStrings.CREATE_REGION__REGIONEXPIRATIONTTL,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__REGIONEXPIRATIONTTL__HELP)
+ Integer regionExpirationTTL,
+ @CliOption (key = CliStrings.CREATE_REGION__REGIONEXPIRATIONTTLACTION,
+ help = CliStrings.CREATE_REGION__REGIONEXPIRATIONTTLACTION__HELP)
+ String regionExpirationTTLAction,
+ @CliOption (key = CliStrings.CREATE_REGION__RECOVERYDELAY,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__RECOVERYDELAY__HELP)
+ Long prRecoveryDelay,
+ @CliOption (key = CliStrings.CREATE_REGION__REDUNDANTCOPIES,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__REDUNDANTCOPIES__HELP)
+ Integer prRedundantCopies,
+ @CliOption (key = CliStrings.CREATE_REGION__STARTUPRECOVERYDDELAY,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__STARTUPRECOVERYDDELAY__HELP)
+ Long prStartupRecoveryDelay,
+ @CliOption (key = CliStrings.CREATE_REGION__TOTALMAXMEMORY,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__TOTALMAXMEMORY__HELP)
+ Long prTotalMaxMemory,
+ @CliOption (key = CliStrings.CREATE_REGION__TOTALNUMBUCKETS,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.CREATE_REGION__TOTALNUMBUCKETS__HELP)
+ Integer prTotalNumBuckets,
+ @CliOption (key = CliStrings.CREATE_REGION__VALUECONSTRAINT,
+ help = CliStrings.CREATE_REGION__VALUECONSTRAINT__HELP)
+ String valueConstraint
+ // NOTICE: keep the region attributes params in alphabetical order
+ ) {
+ Result result = null;
+ XmlEntity xmlEntity = null;
+
+ try {
+ Cache cache = CacheFactory.getAnyInstance();
+
+ if (regionShortcut != null && useAttributesFrom != null) {
+ throw new IllegalArgumentException(CliStrings.CREATE_REGION__MSG__ONLY_ONE_OF_REGIONSHORTCUT_AND_USEATTRIBUESFROM_CAN_BE_SPECIFIED);
+ } else if (regionShortcut == null && useAttributesFrom == null) {
+ throw new IllegalArgumentException(CliStrings.CREATE_REGION__MSG__ONE_OF_REGIONSHORTCUT_AND_USEATTRIBUESFROM_IS_REQUIRED);
+ }
+
+ validateRegionPathAndParent(cache, regionPath);
+ validateGroups(cache, groups);
+
+ RegionFunctionArgs.ExpirationAttrs entryIdle = null;
+ if (entryExpirationIdleTime != null) {
+ entryIdle = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.ENTRY_IDLE, entryExpirationIdleTime, entryExpirationIdleTimeAction);
+ }
+ RegionFunctionArgs.ExpirationAttrs entryTTL = null;
+ if (entryExpirationTTL != null) {
+ entryTTL = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.ENTRY_TTL, entryExpirationTTL, entryExpirationTTLAction);
+ }
+ RegionFunctionArgs.ExpirationAttrs regionIdle = null;
+ if (regionExpirationIdleTime != null) {
+ regionIdle = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.REGION_IDLE, regionExpirationIdleTime, regionExpirationIdleTimeAction);
+ }
+ RegionFunctionArgs.ExpirationAttrs regionTTL = null;
+ if (regionExpirationTTL != null) {
+ regionTTL = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.REGION_TTL, regionExpirationTTL, regionExpirationTTLAction);
+ }
+
+ RegionFunctionArgs regionFunctionArgs = null;
+ if (useAttributesFrom != null) {
+ if (!regionExists(cache, useAttributesFrom)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_REGION_PATH_FOR_0_REGIONPATH_1_NOT_FOUND, new Object[] {CliStrings.CREATE_REGION__USEATTRIBUTESFROM, useAttributesFrom}));
+ }
+
+
+ FetchRegionAttributesFunctionResult<Object, Object> regionAttributesResult = getRegionAttributes(cache, useAttributesFrom);
+ RegionAttributes<?, ?> regionAttributes = regionAttributesResult.getRegionAttributes();
+
+
+ // give preference to user specified plugins than the ones retrieved from other region
+ String[] cacheListenerClasses = cacheListener != null && cacheListener.length != 0 ? cacheListener : regionAttributesResult.getCacheListenerClasses();
+ String cacheLoaderClass = cacheLoader != null ? cacheLoader : regionAttributesResult.getCacheLoaderClass();
+ String cacheWriterClass = cacheWriter != null ? cacheWriter : regionAttributesResult.getCacheWriterClass();;
+
+ regionFunctionArgs = new RegionFunctionArgs(regionPath,
+ useAttributesFrom, skipIfExists, keyConstraint, valueConstraint,
+ statisticsEnabled, entryIdle, entryTTL, regionIdle,
+ regionTTL, diskStore, diskSynchronous, enableAsyncConflation,
+ enableSubscriptionConflation, cacheListenerClasses, cacheLoaderClass,
+ cacheWriterClass, asyncEventQueueIds, gatewaySenderIds,
+ concurrencyChecksEnabled, cloningEnabled, concurrencyLevel,
+ prColocatedWith, prLocalMaxMemory, prRecoveryDelay,
+ prRedundantCopies, prStartupRecoveryDelay,
+ prTotalMaxMemory, prTotalNumBuckets,
+ offHeap, mcastEnabled, regionAttributes);
+
+
+ if (regionAttributes.getPartitionAttributes() == null && regionFunctionArgs.hasPartitionAttributes()) {
+ throw new IllegalArgumentException(
+ CliStrings.format(CliStrings.CREATE_REGION__MSG__OPTION_0_CAN_BE_USED_ONLY_FOR_PARTITIONEDREGION,
+ regionFunctionArgs.getPartitionArgs().getUserSpecifiedPartitionAttributes()) + " " +
+ CliStrings.format(CliStrings.CREATE_REGION__MSG__0_IS_NOT_A_PARITIONEDREGION,
+ useAttributesFrom));
+ }
+ } else {
+ regionFunctionArgs = new RegionFunctionArgs(
+ regionPath, regionShortcut, useAttributesFrom, skipIfExists,
+ keyConstraint, valueConstraint, statisticsEnabled, entryIdle, entryTTL,
+ regionIdle, regionTTL, diskStore, diskSynchronous,
+ enableAsyncConflation, enableSubscriptionConflation, cacheListener,
+ cacheLoader, cacheWriter, asyncEventQueueIds, gatewaySenderIds,
+ concurrencyChecksEnabled, cloningEnabled, concurrencyLevel,
+ prColocatedWith, prLocalMaxMemory, prRecoveryDelay,
+ prRedundantCopies, prStartupRecoveryDelay,
+ prTotalMaxMemory, prTotalNumBuckets, null,compressor, offHeap , mcastEnabled);
+
+ if (!regionShortcut.name().startsWith("PARTITION") && regionFunctionArgs.hasPartitionAttributes()) {
+ throw new IllegalArgumentException(
+ CliStrings.format(CliStrings.CREATE_REGION__MSG__OPTION_0_CAN_BE_USED_ONLY_FOR_PARTITIONEDREGION,
+ regionFunctionArgs.getPartitionArgs().getUserSpecifiedPartitionAttributes()) + " " +
+ CliStrings.format(CliStrings.CREATE_REGION__MSG__0_IS_NOT_A_PARITIONEDREGION,
+ useAttributesFrom));
+ }
+ }
+
+ validateRegionFunctionArgs(cache, regionFunctionArgs);
+
+ Set<DistributedMember> membersToCreateRegionOn = null;
+ if (groups != null && groups.length != 0) {
+ membersToCreateRegionOn = CliUtil.getDistributedMembersByGroup(cache, groups);
+ // have only normal members from the group
+ for (Iterator<DistributedMember> it = membersToCreateRegionOn.iterator(); it.hasNext();) {
+ DistributedMember distributedMember = it.next();
+ if ( ((InternalDistributedMember)distributedMember).getVmKind() == DistributionManager.LOCATOR_DM_TYPE ) {
+ it.remove();
+ }
+ }
+ } else {
+ membersToCreateRegionOn = CliUtil.getAllNormalMembers(cache);
+ }
+
+ if (membersToCreateRegionOn.isEmpty()) {
+ return ResultBuilder.createUserErrorResult(CliStrings.NO_CACHING_MEMBERS_FOUND_MESSAGE);
+ }
+
+ ResultCollector<?, ?> resultCollector = CliUtil.executeFunction(RegionCreateFunction.INSTANCE, regionFunctionArgs, membersToCreateRegionOn);
+ @SuppressWarnings("unchecked")
+ List<CliFunctionResult> regionCreateResults = (List<CliFunctionResult>) resultCollector.getResult();
+
+ TabularResultData tabularResultData = ResultBuilder.createTabularResultData();
+ final String errorPrefix = "ERROR: ";
+ for (CliFunctionResult regionCreateResult : regionCreateResults) {
+ boolean success = regionCreateResult.isSuccessful();
+ tabularResultData.accumulate("Member", regionCreateResult.getMemberIdOrName());
+ tabularResultData.accumulate("Status", (success ? "" : errorPrefix) + regionCreateResult.getMessage());
+
+ if (success) {
+ xmlEntity = regionCreateResult.getXmlEntity();
+ }
+ }
+
+ result = ResultBuilder.buildResult(tabularResultData);
+ verifyDistributedRegionMbean(cache, regionPath);
+
+ } catch (IllegalArgumentException e) {
+ LogWrapper.getInstance().info(e.getMessage());
+ result = ResultBuilder.createUserErrorResult(e.getMessage());
+ } catch (IllegalStateException e) {
+ LogWrapper.getInstance().info(e.getMessage());
+ result = ResultBuilder.createUserErrorResult(e.getMessage());
+ } catch (RuntimeException e) {
+ LogWrapper.getInstance().info(e.getMessage(), e);
+ result = ResultBuilder.createGemFireErrorResult(e.getMessage());
+
+ }
+ if (xmlEntity != null) {
+ result.setCommandPersisted((new SharedConfigurationWriter()).addXmlEntity(xmlEntity, groups));
+ }
+ return result;
+ }
+
+
+ public boolean verifyDistributedRegionMbean(Cache cache, String regionName){
+ GemFireCacheImpl gemfireCache = (GemFireCacheImpl) cache;
+ int federationInterval = gemfireCache.getDistributedSystem().getConfig().getJmxManagerUpdateRate();
+ long timeEnd = System.currentTimeMillis() + federationInterval + 50;
+
+ for( ; System.currentTimeMillis() <= timeEnd ; ){
+ try{
+ DistributedRegionMXBean bean = ManagementService.getManagementService(cache).getDistributedRegionMXBean(regionName);
+ if (bean == null){
+ bean = ManagementService.getManagementService(cache).getDistributedRegionMXBean(Region.SEPARATOR + regionName);
+ }
+ if(bean != null){
+ return true;
+ }else{
+ Thread.sleep(2);
+ }
+ }catch(Exception ex){
+ continue;
+ }
+ }
+ return false;
+ }
+
+ @CliCommand (value = CliStrings.ALTER_REGION, help = CliStrings.ALTER_REGION__HELP)
+ @CliMetaData (relatedTopic = CliStrings.TOPIC_GEMFIRE_REGION, writesToSharedConfiguration = true)
++ @ResourceOperation(resource = Resource.DISTRIBUTED_SYSTEM, operation= ResourceConstants.ALTER_REGION)
+ public Result alterRegion(
+ @CliOption (key = CliStrings.ALTER_REGION__REGION,
+ mandatory = true,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.ALTER_REGION__REGION__HELP)
+ String regionPath,
+ @CliOption (key = CliStrings.ALTER_REGION__GROUP,
+ optionContext = ConverterHint.MEMBERGROUP,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ help = CliStrings.ALTER_REGION__GROUP__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] groups,
+ @CliOption (key = CliStrings.ALTER_REGION__ENTRYEXPIRATIONIDLETIME,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "-1",
+ help = CliStrings.ALTER_REGION__ENTRYEXPIRATIONIDLETIME__HELP)
+ Integer entryExpirationIdleTime,
+ @CliOption (key = CliStrings.ALTER_REGION__ENTRYEXPIRATIONIDLETIMEACTION,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = CliMetaData.ANNOTATION_DEFAULT_VALUE,
+ help = CliStrings.ALTER_REGION__ENTRYEXPIRATIONIDLETIMEACTION__HELP)
+ String entryExpirationIdleTimeAction,
+ @CliOption (key = CliStrings.ALTER_REGION__ENTRYEXPIRATIONTIMETOLIVE,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "-1",
+ help = CliStrings.ALTER_REGION__ENTRYEXPIRATIONTIMETOLIVE__HELP)
+ Integer entryExpirationTTL,
+ @CliOption (key = CliStrings.ALTER_REGION__ENTRYEXPIRATIONTTLACTION,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = CliMetaData.ANNOTATION_DEFAULT_VALUE,
+ help = CliStrings.ALTER_REGION__ENTRYEXPIRATIONTTLACTION__HELP)
+ String entryExpirationTTLAction,
+ @CliOption (key = CliStrings.ALTER_REGION__REGIONEXPIRATIONIDLETIME,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "-1",
+ help = CliStrings.ALTER_REGION__REGIONEXPIRATIONIDLETIME__HELP)
+ Integer regionExpirationIdleTime,
+ @CliOption (key = CliStrings.ALTER_REGION__REGIONEXPIRATIONIDLETIMEACTION,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = CliMetaData.ANNOTATION_DEFAULT_VALUE,
+ help = CliStrings.ALTER_REGION__REGIONEXPIRATIONIDLETIMEACTION__HELP)
+ String regionExpirationIdleTimeAction,
+ @CliOption (key = CliStrings.ALTER_REGION__REGIONEXPIRATIONTTL,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "-1",
+ help = CliStrings.ALTER_REGION__REGIONEXPIRATIONTTL__HELP)
+ Integer regionExpirationTTL,
+ @CliOption (key = CliStrings.ALTER_REGION__REGIONEXPIRATIONTTLACTION,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = CliMetaData.ANNOTATION_DEFAULT_VALUE,
+ help = CliStrings.ALTER_REGION__REGIONEXPIRATIONTTLACTION__HELP)
+ String regionExpirationTTLAction,
+ @CliOption (key = CliStrings.ALTER_REGION__CACHELISTENER,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "",
+ help = CliStrings.ALTER_REGION__CACHELISTENER__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] cacheListeners,
+ @CliOption (key = CliStrings.ALTER_REGION__CACHELOADER,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = CliMetaData.ANNOTATION_DEFAULT_VALUE,
+ help = CliStrings.ALTER_REGION__CACHELOADER__HELP)
+ String cacheLoader,
+ @CliOption (key = CliStrings.ALTER_REGION__CACHEWRITER,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = CliMetaData.ANNOTATION_DEFAULT_VALUE,
+ help = CliStrings.ALTER_REGION__CACHEWRITER__HELP)
+ String cacheWriter,
+ @CliOption (key = CliStrings.ALTER_REGION__ASYNCEVENTQUEUEID,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "",
+ help = CliStrings.ALTER_REGION__ASYNCEVENTQUEUEID__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] asyncEventQueueIds,
+ @CliOption (key = CliStrings.ALTER_REGION__GATEWAYSENDERID,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "",
+ help = CliStrings.ALTER_REGION__GATEWAYSENDERID__HELP)
+ @CliMetaData (valueSeparator = ",")
+ String[] gatewaySenderIds,
+ @CliOption (key = CliStrings.ALTER_REGION__CLONINGENABLED,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "false",
+ help = CliStrings.ALTER_REGION__CLONINGENABLED__HELP)
+ Boolean cloningEnabled,
+ @CliOption (key = CliStrings.ALTER_REGION__EVICTIONMAX,
+ unspecifiedDefaultValue = CliMetaData.ANNOTATION_NULL_VALUE,
+ specifiedDefaultValue = "0",
+ help = CliStrings.ALTER_REGION__EVICTIONMAX__HELP)
+ Integer evictionMax) {
+ Result result = null;
+ XmlEntity xmlEntity = null;
+
+ try {
+ Cache cache = CacheFactory.getAnyInstance();
+
+ if (groups != null) {
+ validateGroups(cache, groups);
+ }
+
+ RegionFunctionArgs.ExpirationAttrs entryIdle = null;
+ if (entryExpirationIdleTime != null || entryExpirationIdleTimeAction != null) {
+ if (entryExpirationIdleTime != null && entryExpirationIdleTime == -1) {
+ entryExpirationIdleTime = ExpirationAttributes.DEFAULT.getTimeout();
+ }
+ if (CliMetaData.ANNOTATION_DEFAULT_VALUE.equals(entryExpirationIdleTimeAction)) {
+ entryExpirationIdleTimeAction = ExpirationAttributes.DEFAULT.getAction().toString();
+ }
+ entryIdle = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.ENTRY_IDLE,
+ entryExpirationIdleTime, entryExpirationIdleTimeAction);
+ }
+ RegionFunctionArgs.ExpirationAttrs entryTTL = null;
+ if (entryExpirationTTL != null || entryExpirationTTLAction != null) {
+ if (entryExpirationTTL != null && entryExpirationTTL == -1) {
+ entryExpirationTTL = ExpirationAttributes.DEFAULT.getTimeout();
+ }
+ if (CliMetaData.ANNOTATION_DEFAULT_VALUE.equals(entryExpirationTTLAction)) {
+ entryExpirationTTLAction = ExpirationAttributes.DEFAULT.getAction().toString();
+ }
+ entryTTL = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.ENTRY_TTL,
+ entryExpirationTTL, entryExpirationTTLAction);
+ }
+ RegionFunctionArgs.ExpirationAttrs regionIdle = null;
+ if (regionExpirationIdleTime != null || regionExpirationIdleTimeAction != null) {
+ if (regionExpirationIdleTime != null && regionExpirationIdleTime == -1) {
+ regionExpirationIdleTime = ExpirationAttributes.DEFAULT.getTimeout();
+ }
+ if (CliMetaData.ANNOTATION_DEFAULT_VALUE.equals(regionExpirationIdleTimeAction)) {
+ regionExpirationIdleTimeAction = ExpirationAttributes.DEFAULT.getAction().toString();
+ }
+ regionIdle = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.REGION_IDLE,
+ regionExpirationIdleTime, regionExpirationIdleTimeAction);
+ }
+ RegionFunctionArgs.ExpirationAttrs regionTTL = null;
+ if (regionExpirationTTL != null || regionExpirationTTLAction != null) {
+ if (regionExpirationTTL != null && regionExpirationTTL == -1) {
+ regionExpirationTTL = ExpirationAttributes.DEFAULT.getTimeout();
+ }
+ if (CliMetaData.ANNOTATION_DEFAULT_VALUE.equals(regionExpirationTTLAction)) {
+ regionExpirationTTLAction = ExpirationAttributes.DEFAULT.getAction().toString();
+ }
+ regionTTL = new RegionFunctionArgs.ExpirationAttrs(RegionFunctionArgs.ExpirationAttrs.ExpirationFor.REGION_TTL,
+ regionExpirationTTL, regionExpirationTTLAction);
+ }
+
+ cacheLoader = convertDefaultValue(cacheLoader, StringUtils.EMPTY_STRING);
+ cacheWriter = convertDefaultValue(cacheWriter, StringUtils.EMPTY_STRING);
+
+ RegionFunctionArgs regionFunctionArgs = null;
+ regionFunctionArgs = new RegionFunctionArgs(regionPath, null, null, false, null, null, null, entryIdle, entryTTL,
+ regionIdle, regionTTL, null, null, null, null, cacheListeners, cacheLoader, cacheWriter, asyncEventQueueIds,
+ gatewaySenderIds, null, cloningEnabled, null, null, null, null, null, null, null, null, evictionMax, null, null, null);
+
+ Set<String> cacheListenersSet = regionFunctionArgs.getCacheListeners();
+ if (cacheListenersSet != null && !cacheListenersSet.isEmpty()) {
+ for (String cacheListener : cacheListenersSet) {
+ if (!isClassNameValid(cacheListener)) {
+ throw new IllegalArgumentException(CliStrings.format(
+ CliStrings.ALTER_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_CACHELISTENER_0_IS_INVALID,
+ new Object[] { cacheListener }));
+ }
+ }
+ }
+
+ if (cacheLoader != null && !isClassNameValid(cacheLoader)) {
+ throw new IllegalArgumentException(CliStrings.format(
+ CliStrings.ALTER_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_CACHELOADER_0_IS_INVALID, new Object[] { cacheLoader }));
+ }
+
+ if (cacheWriter != null && !isClassNameValid(cacheWriter)) {
+ throw new IllegalArgumentException(CliStrings.format(
+ CliStrings.ALTER_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_CACHEWRITER_0_IS_INVALID, new Object[] { cacheWriter }));
+ }
+
+ if (evictionMax != null && evictionMax < 0) {
+ throw new IllegalArgumentException(CliStrings.format(
+ CliStrings.ALTER_REGION__MSG__SPECIFY_POSITIVE_INT_FOR_EVICTIONMAX_0_IS_NOT_VALID, new Object[] { evictionMax }));
+ }
+
+ Set<DistributedMember> targetMembers;
+ try {
+ targetMembers = CliUtil.findAllMatchingMembers(groups, null);
+ } catch (CommandResultException crex) {
+ return crex.getResult();
+ }
+
+ ResultCollector<?, ?> resultCollector = CliUtil.executeFunction(new RegionAlterFunction(), regionFunctionArgs, targetMembers);
+ List<CliFunctionResult> regionAlterResults = (List<CliFunctionResult>) resultCollector.getResult();
+
+ TabularResultData tabularResultData = ResultBuilder.createTabularResultData();
+ final String errorPrefix = "ERROR: ";
+ for (CliFunctionResult regionAlterResult : regionAlterResults) {
+ boolean success = regionAlterResult.isSuccessful();
+ tabularResultData.accumulate("Member", regionAlterResult.getMemberIdOrName());
+ if (success) {
+ tabularResultData.accumulate("Status", regionAlterResult.getMessage());
+ xmlEntity = regionAlterResult.getXmlEntity();
+ } else {
+ tabularResultData.accumulate("Status", errorPrefix + regionAlterResult.getMessage());
+ tabularResultData.setStatus(Status.ERROR);
+ }
+ }
+ result = ResultBuilder.buildResult(tabularResultData);
+ } catch (IllegalArgumentException e) {
+ LogWrapper.getInstance().info(e.getMessage());
+ result = ResultBuilder.createUserErrorResult(e.getMessage());
+ } catch (IllegalStateException e) {
+ LogWrapper.getInstance().info(e.getMessage());
+ result = ResultBuilder.createUserErrorResult(e.getMessage());
+ } catch (RuntimeException e) {
+ LogWrapper.getInstance().info(e.getMessage(), e);
+ result = ResultBuilder.createGemFireErrorResult(e.getMessage());
+ }
+ if (xmlEntity != null) {
+ result.setCommandPersisted((new SharedConfigurationWriter()).addXmlEntity(xmlEntity, groups));
+ }
+ return result;
+ }
+
+ private static boolean regionExists(Cache cache, String regionPath) {
+ boolean regionFound = false;
+ if (regionPath != null && !Region.SEPARATOR.equals(regionPath)) {
+ ManagementService managementService = ManagementService.getExistingManagementService(cache);
+ DistributedSystemMXBean dsMBean = managementService.getDistributedSystemMXBean();
+
+ String[] allRegionPaths = dsMBean.listAllRegionPaths();
+ for (int i = 0; i < allRegionPaths.length; i++) {
+ if (allRegionPaths[i].equals(regionPath)) {
+ regionFound = true;
+ break;
+ }
+ }
+ }
+ return regionFound;
+ }
+
+ private void validateRegionPathAndParent(Cache cache, String regionPath) {
+ if (regionPath == null || "".equals(regionPath)) {
+ throw new IllegalArgumentException(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_REGION_PATH);
+ }
+ // If a region path indicates a sub-region, check whether the parent region exists
+ RegionPath regionPathData = new RegionPath(regionPath);
+ String parentRegionPath = regionPathData.getParent();
+ if (parentRegionPath != null && !Region.SEPARATOR.equals(parentRegionPath)) {
+ if (!regionExists(cache, parentRegionPath)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__PARENT_REGION_FOR_0_DOESNOT_EXIST, new Object[] {regionPath}));
+ }
+ }
+ }
+
+
+ private void validateGroups(Cache cache, String[] groups) {
+ if (groups != null && groups.length != 0) {
+ Set<String> existingGroups = new HashSet<String>();
+ Set<DistributedMember> members = CliUtil.getAllNormalMembers(cache);
+ for (DistributedMember distributedMember : members) {
+ List<String> memberGroups = distributedMember.getGroups();
+ existingGroups.addAll(memberGroups);
+ }
+ List<String> groupsList = new ArrayList<String>(Arrays.asList(groups));
+ groupsList.removeAll(existingGroups);
+
+ if (!groupsList.isEmpty()) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__GROUPS_0_ARE_INVALID, new Object[] {String.valueOf(groupsList)}));
+ }
+ }
+ }
+
+ private void validateRegionFunctionArgs(Cache cache, RegionFunctionArgs regionFunctionArgs) {
+ if (regionFunctionArgs.getRegionPath() == null) {
+ throw new IllegalArgumentException(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_REGION_PATH);
+ }
+
+ ManagementService managementService = ManagementService.getExistingManagementService(cache);
+ DistributedSystemMXBean dsMBean = managementService.getDistributedSystemMXBean();
+
+ String useAttributesFrom = regionFunctionArgs.getUseAttributesFrom();
+ if (useAttributesFrom != null && !useAttributesFrom.isEmpty() && regionExists(cache, useAttributesFrom)) {
+ if (!regionExists(cache, useAttributesFrom)) { // check already done in createRegion !!!
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_REGION_PATH_FOR_0_REGIONPATH_1_NOT_FOUND, new Object[] {CliStrings.CREATE_REGION__USEATTRIBUTESFROM, useAttributesFrom}));
+ }
+ if (!regionFunctionArgs.isSetUseAttributesFrom() || regionFunctionArgs.getRegionAttributes() == null) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__COULD_NOT_RETRIEVE_REGION_ATTRS_FOR_PATH_0_VERIFY_REGION_EXISTS, useAttributesFrom));
+ }
+ }
+
+ if (regionFunctionArgs.hasPartitionAttributes()) {
+ RegionFunctionArgs.PartitionArgs partitionArgs = regionFunctionArgs.getPartitionArgs();
+ String colocatedWith = partitionArgs.getPrColocatedWith();
+ if (colocatedWith != null && !colocatedWith.isEmpty()) {
+ String[] listAllRegionPaths = dsMBean.listAllRegionPaths();
+ String foundRegionPath = null;
+ for (String regionPath : listAllRegionPaths) {
+ if (regionPath.equals(colocatedWith)) {
+ foundRegionPath = regionPath;
+ break;
+ }
+ }
+ if (foundRegionPath == null) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_REGION_PATH_FOR_0_REGIONPATH_1_NOT_FOUND, new Object[] {CliStrings.CREATE_REGION__COLOCATEDWITH, colocatedWith}));
+ }
+ ManagementService mgmtService = ManagementService.getExistingManagementService(cache);
+ DistributedRegionMXBean distributedRegionMXBean = mgmtService.getDistributedRegionMXBean(foundRegionPath);
+ String regionType = distributedRegionMXBean.getRegionType();
+ if ( ! ( DataPolicy.PARTITION.toString().equals(regionType) || DataPolicy.PERSISTENT_PARTITION.toString().equals(regionType) ) ) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__COLOCATEDWITH_REGION_0_IS_NOT_PARTITIONEDREGION, new Object[] {colocatedWith}));
+ }
+ }
+ if (partitionArgs.isSetPRLocalMaxMemory()) {
+ int prLocalMaxMemory = partitionArgs.getPrLocalMaxMemory();
+ if (prLocalMaxMemory < 0) {
+ throw new IllegalArgumentException(LocalizedStrings.AttributesFactory_PARTITIONATTRIBUTES_LOCALMAXMEMORY_MUST_NOT_BE_NEGATIVE.toLocalizedString());
+ }
+ }
+ if (partitionArgs.isSetPRTotalMaxMemory()) {
+ long prTotalMaxMemory = partitionArgs.getPrTotalMaxMemory();
+ if (prTotalMaxMemory <= 0) {
+ throw new IllegalArgumentException(LocalizedStrings.AttributesFactory_TOTAL_SIZE_OF_PARTITION_REGION_MUST_BE_0.toLocalizedString());
+ }
+ }
+ if (partitionArgs.isSetPRRedundantCopies()) {
+ int prRedundantCopies = partitionArgs.getPrRedundantCopies();
+ switch (prRedundantCopies) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__REDUNDANT_COPIES_SHOULD_BE_ONE_OF_0123, new Object[] {prRedundantCopies}));
+ }
+ }
+ // Validation for the following is not known yet
+ // if (partitionArgs.isSetPRTotalNumBuckets()) {
+ // int prTotalNumBuckets = partitionArgs.getPrTotalNumBuckets();
+ // }
+ // if (partitionArgs.isSetPRStartupRecoveryDelay()) {
+ // long prStartupRecoveryDelay = partitionArgs.getPrStartupRecoveryDelay();
+ // }
+ // if (partitionArgs.isSetPRRecoveryDelay()) {
+ // long prRecoveryDelay = partitionArgs.getPrRecoveryDelay();
+ // }
+ }
+
+ String keyConstraint = regionFunctionArgs.getKeyConstraint();
+ if (keyConstraint != null && !isClassNameValid(keyConstraint)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_KEYCONSTRAINT_0_IS_INVALID, new Object[] {keyConstraint}));
+ }
+
+ String valueConstraint = regionFunctionArgs.getValueConstraint();
+ if (valueConstraint != null && !isClassNameValid(valueConstraint)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_VALUECONSTRAINT_0_IS_INVALID, new Object[] {valueConstraint}));
+ }
+
+ Set<String> cacheListeners = regionFunctionArgs.getCacheListeners();
+ if (cacheListeners != null && !cacheListeners.isEmpty()) {
+ for (String cacheListener : cacheListeners) {
+ if (!isClassNameValid(cacheListener)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_CACHELISTENER_0_IS_INVALID, new Object[] {cacheListener}));
+ }
+ }
+ }
+
+ String cacheLoader = regionFunctionArgs.getCacheLoader();
+ if (cacheLoader != null && !isClassNameValid(cacheLoader)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_CACHELOADER_0_IS_INVALID, new Object[] {cacheLoader}));
+ }
+
+ String cacheWriter = regionFunctionArgs.getCacheWriter();
+ if (cacheWriter != null && !isClassNameValid(cacheWriter)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_CLASSNAME_FOR_CACHEWRITER_0_IS_INVALID, new Object[] {cacheWriter}));
+ }
+
+ Set<String> gatewaySenderIds = regionFunctionArgs.getGatewaySenderIds();
+ if (gatewaySenderIds != null && !gatewaySenderIds.isEmpty()) {
+ String[] gatewaySenders = dsMBean.listGatewaySenders();
+ if (gatewaySenders.length == 0) {
+ throw new IllegalArgumentException(CliStrings.CREATE_REGION__MSG__NO_GATEWAYSENDERS_IN_THE_SYSTEM);
+ } else {
+ List<String> gatewaySendersList = new ArrayList<String>(Arrays.asList(gatewaySenders));
+ gatewaySenderIds = new HashSet<String>(gatewaySenderIds);
+ gatewaySenderIds.removeAll(gatewaySendersList);
+ if (!gatewaySenderIds.isEmpty()) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_GATEWAYSENDER_ID_UNKNOWN_0, new Object[] {gatewaySenderIds}));
+ }
+ }
+ }
+
+ if (regionFunctionArgs.isSetConcurrencyLevel()) {
+ int concurrencyLevel = regionFunctionArgs.getConcurrencyLevel();
+ if (concurrencyLevel < 0) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_POSITIVE_INT_FOR_CONCURRENCYLEVEL_0_IS_NOT_VALID, new Object[] {concurrencyLevel}));
+ }
+ }
+
+ String diskStore = regionFunctionArgs.getDiskStore();
+ if (diskStore != null) {
+ RegionShortcut regionShortcut = regionFunctionArgs.getRegionShortcut();
+ if (regionShortcut != null && !PERSISTENT_OVERFLOW_SHORTCUTS.contains(regionShortcut)) {
+ String subMessage = LocalizedStrings.DiskStore_IS_USED_IN_NONPERSISTENT_REGION.toLocalizedString();
+ String message = subMessage + ". " + CliStrings.format(CliStrings.CREATE_REGION__MSG__USE_ONE_OF_THESE_SHORTCUTS_0, new Object[] {String.valueOf(PERSISTENT_OVERFLOW_SHORTCUTS)});
+
+ throw new IllegalArgumentException(message);
+ }
+
+ RegionAttributes<?, ?> regionAttributes = regionFunctionArgs.getRegionAttributes();
+ if (regionAttributes != null && !regionAttributes.getDataPolicy().withPersistence()) {
+ String subMessage = LocalizedStrings.DiskStore_IS_USED_IN_NONPERSISTENT_REGION.toLocalizedString();
+ String message = subMessage+ ". " + CliStrings.format(CliStrings.CREATE_REGION__MSG__USE_ATTRIBUTES_FROM_REGION_0_IS_NOT_WITH_PERSISTENCE,
+ new Object[] { String.valueOf(regionFunctionArgs.getUseAttributesFrom()) });
+
+ throw new IllegalArgumentException(message);
+ }
+
+ if (!diskStoreExists(cache, diskStore)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_DISKSTORE_UNKNOWN_DISKSTORE_0, new Object[] {diskStore}));
+ }
+ }
+
+ RegionFunctionArgs.ExpirationAttrs entryExpirationIdleTime = regionFunctionArgs.getEntryExpirationIdleTime();
+ RegionFunctionArgs.ExpirationAttrs entryExpirationTTL = regionFunctionArgs.getEntryExpirationTTL();
+ RegionFunctionArgs.ExpirationAttrs regionExpirationIdleTime = regionFunctionArgs.getRegionExpirationIdleTime();
+ RegionFunctionArgs.ExpirationAttrs regionExpirationTTL = regionFunctionArgs.getRegionExpirationTTL();
+
+ if ((!regionFunctionArgs.isSetStatisticsEnabled() || !regionFunctionArgs.isStatisticsEnabled())
+ && (entryExpirationIdleTime != null || entryExpirationTTL != null
+ || regionExpirationIdleTime != null || regionExpirationTTL != null)) {
+ String message = LocalizedStrings.AttributesFactory_STATISTICS_MUST_BE_ENABLED_FOR_EXPIRATION.toLocalizedString();
+ throw new IllegalArgumentException(message + ".");
+ }
+
+ boolean compressorFailure = false;
+ if(regionFunctionArgs.isSetCompressor()) {
+ String compressorClassName = regionFunctionArgs.getCompressor();
+ Object compressor = null;
+ try {
+ Class<?> compressorClass = (Class<?>) ClassPathLoader.getLatest().forName(compressorClassName);
+ compressor = compressorClass.newInstance();
+ } catch (InstantiationException e) {
+ compressorFailure = true;
+ } catch (IllegalAccessException e) {
+ compressorFailure = true;
+ } catch (ClassNotFoundException e) {
+ compressorFailure = true;
+ }
+
+ if (compressorFailure || !(compressor instanceof Compressor)) {
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__INVALID_COMPRESSOR,
+ new Object[] { regionFunctionArgs.getCompressor() }));
+ }
+ }
+ }
+
+ private boolean diskStoreExists(Cache cache, String diskStoreName) {
+ ManagementService managementService = ManagementService.getExistingManagementService(cache);
+ DistributedSystemMXBean dsMXBean = managementService.getDistributedSystemMXBean();
+ Map<String, String[]> diskstore = dsMXBean.listMemberDiskstore();
+
+ Set<Entry<String, String[]>> entrySet = diskstore.entrySet();
+
+ for (Entry<String, String[]> entry : entrySet) {
+ String[] value = entry.getValue();
+ if (CliUtil.contains(value, diskStoreName)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private static <K, V> FetchRegionAttributesFunctionResult<K, V> getRegionAttributes(Cache cache, String regionPath) {
+ if (!isClusterwideSameConfig(cache, regionPath)) {
+ throw new IllegalStateException(CliStrings.format(CliStrings.CREATE_REGION__MSG__USE_ATTRIBUTES_FORM_REGIONS_EXISTS_BUT_DIFFERENT_SCOPE_OR_DATAPOLICY_USE_DESCRIBE_REGION_FOR_0, regionPath));
+ }
+ FetchRegionAttributesFunctionResult<K, V> attributes = null;
+
+ // First check whether the region exists on a this manager, if yes then no
+ // need to use FetchRegionAttributesFunction to fetch RegionAttributes
+ try {
+ attributes = FetchRegionAttributesFunction.getRegionAttributes(regionPath);
+ } catch (IllegalArgumentException e) {
+ /* region doesn't exist on the manager */
+ }
+
+ if (attributes == null) {
+ // find first member which has the region
+ Set<DistributedMember> regionAssociatedMembers = CliUtil.getRegionAssociatedMembers(regionPath, cache, false);
+ if (regionAssociatedMembers != null && !regionAssociatedMembers.isEmpty()) {
+ DistributedMember distributedMember = regionAssociatedMembers.iterator().next();
+ ResultCollector<?, ?> resultCollector = CliUtil.executeFunction(FetchRegionAttributesFunction.INSTANCE, regionPath, distributedMember);
+ List<?> resultsList = (List<?>) resultCollector.getResult();
+
+ if (resultsList != null && !resultsList.isEmpty()) {
+ for (int i = 0; i < resultsList.size(); i++) {
+ Object object = resultsList.get(i);
+ if (object instanceof IllegalArgumentException) {
+ throw (IllegalArgumentException) object;
+ } else if (object instanceof Throwable) {
+ Throwable th = (Throwable) object;
+ LogWrapper.getInstance().info(CliUtil.stackTraceAsString((th)));
+ throw new IllegalArgumentException(CliStrings.format(CliStrings.CREATE_REGION__MSG__COULD_NOT_RETRIEVE_REGION_ATTRS_FOR_PATH_0_REASON_1, new Object[] {regionPath, th.getMessage()}));
+ } else { // has to be RegionAttributes
+ @SuppressWarnings("unchecked") // to avoid warning :(
+ FetchRegionAttributesFunctionResult<K, V> regAttr = ((FetchRegionAttributesFunctionResult<K, V>) object);
+ if (attributes == null) {
+ attributes = regAttr;
+ break;
+ } //attributes null check
+ }// not IllegalArgumentException or other throwable
+ }// iterate over list - there should be only one result in the list
+ }// result list is not null or mpty
+ }// regionAssociatedMembers is not-empty
+ }// attributes are null because do not exist on local member
+
+
+ return attributes;
+ }
+
+ private static boolean isClusterwideSameConfig(Cache cache, String regionPath) {
+ ManagementService managementService = ManagementService.getExistingManagementService(cache);
+
+ DistributedSystemMXBean dsMXBean = managementService.getDistributedSystemMXBean();
+
+ Set<DistributedMember> allMembers = CliUtil.getAllNormalMembers(cache);
+
+ RegionAttributesData regionAttributesToValidateAgainst = null;
+ for (DistributedMember distributedMember : allMembers) {
+ ObjectName regionObjectName;
+ try {
+ regionObjectName = dsMXBean.fetchRegionObjectName(CliUtil.getMemberNameOrId(distributedMember), regionPath);
+ RegionMXBean regionMBean = managementService.getMBeanInstance(regionObjectName, RegionMXBean.class);
+ RegionAttributesData regionAttributes = regionMBean.listRegionAttributes();
+
+ if (regionAttributesToValidateAgainst == null) {
+ regionAttributesToValidateAgainst = regionAttributes;
+ } else if ( !(regionAttributesToValidateAgainst.getScope().equals(regionAttributes.getScope()) ||
+ regionAttributesToValidateAgainst.getDataPolicy().equals(regionAttributes.getDataPolicy())) ) {
+ return false;
+ }
+ } catch (Exception e) {
+ //ignore
+ }
+ }
+
+ return true;
+ }
+
+ private boolean isClassNameValid(String fqcn) {
+ if (fqcn.isEmpty()) {
+ return true;
+ }
+
+ String regex = "([\\p{L}_$][\\p{L}\\p{N}_$]*\\.)*[\\p{L}_$][\\p{L}\\p{N}_$]*";
+ return Pattern.matches(regex, fqcn);
+ }
+
+ @CliCommand(value = { CliStrings.DESTROY_REGION }, help = CliStrings.DESTROY_REGION__HELP)
+ @CliMetaData(shellOnly = false, relatedTopic = CliStrings.TOPIC_GEMFIRE_REGION, writesToSharedConfiguration = true)
++ @ResourceOperation(resource = Resource.DISTRIBUTED_SYSTEM, operation= ResourceConstants.DESTROY_REGION)
+ public Result destroyRegion(
+ @CliOption(key = CliStrings.DESTROY_REGION__REGION,
+ optionContext = ConverterHint.REGIONPATH,
+ mandatory = true,
+ help = CliStrings.DESTROY_REGION__REGION__HELP)
+ String regionPath) {
+ Result result = null;
+ XmlEntity xmlEntity = null;
+ try {
+ if (regionPath != null) {
+ if (regionPath.trim().isEmpty()) { // unlikely through gfsh
+ result = ResultBuilder.createInfoResult(CliStrings.format(CliStrings.DESTROY_REGION__MSG__REGIONPATH_0_NOT_VALID,
+ new Object[] { regionPath }));
+ } else if (regionPath.equals(Region.SEPARATOR)) {
+ result = ResultBuilder.createUserErrorResult(CliStrings.format(CliStrings.DESTROY_REGION__MSG__REGIONPATH_0_NOT_VALID,
+ new Object[] { regionPath }));
+ } else {
+ boolean isRegionDestroyed = false;
+ String message = "";
+ Cache cache = CacheFactory.getAnyInstance();
+ ManagementService managementService = ManagementService.getExistingManagementService(cache);
+ String regionPathToUse = regionPath;
+ String regionName = regionPath.startsWith(Region.SEPARATOR) ? regionPath.substring(1) : regionPath;
+
+ if (!regionPathToUse.startsWith(Region.SEPARATOR)) {
+ regionPathToUse = Region.SEPARATOR + regionPathToUse;
+ }
+ Set<DistributedMember>[] regionMembersList = findMembersForRegion(cache, managementService, regionPathToUse);
+ if (regionMembersList != null) {
+ Set<DistributedMember> regionMembers = regionMembersList[0];
+ Set<DistributedMember> localRegionMembers = regionMembersList[1];
+
+ if (regionMembers != null && !regionMembers.isEmpty()) { // Distributed Region with this region path exists
+ Region<?, ?> regionInThisCache = cache.getRegion(regionPath);
+ if (regionInThisCache != null) {// exists in local cache?
+ regionInThisCache.destroyRegion(); // this is for a Distributed Region & destroy event will be propagated
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__REGION_0_1_DESTROYED, new Object[] { regionPath, /*subRegionMessage*/"" });
+ xmlEntity = new XmlEntity(CacheXml.REGION, "name", regionName);
+ isRegionDestroyed = true;
+ } else {
+ CliFunctionResult destroyRegionResult = null;
+ Iterator<DistributedMember> it = regionMembers.iterator();
+ DistributedMember firstMember = it.next(); // regionMembers is not empty
+
+ ResultCollector<?, ?> resultCollector = CliUtil.executeFunction(RegionDestroyFunction.INSTANCE, regionPath, firstMember);
+ List<CliFunctionResult> destroyRegionResults = (List<CliFunctionResult>) resultCollector.getResult();
+
+ destroyRegionResult = destroyRegionResults.get(0);
+
+ if (destroyRegionResult.isSuccessful()) {
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__REGION_0_1_DESTROYED, new Object[] { regionPath, /*subRegionMessage*/"" });
+ xmlEntity = destroyRegionResult.getXmlEntity();
+ isRegionDestroyed = true;
+ } else if (destroyRegionResult.getThrowable() != null) {
+ Throwable t = destroyRegionResult.getThrowable();
+ LogWrapper.getInstance().info(t.getMessage(), t);
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__ERROR_OCCURRED_WHILE_DESTROYING_0_REASON_1,
+ new Object[] { regionPath, t.getMessage() });
+ isRegionDestroyed = false;
+ } else {
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__UNKNOWN_RESULT_WHILE_DESTROYING_REGION_0_REASON_1,
+ new Object[] { regionPath, destroyRegionResult.getMessage() });
+ isRegionDestroyed = false;
+ }
+ }
+ }
+
+ if (localRegionMembers != null && !localRegionMembers.isEmpty()) { // Local Regions with this region path also exist
+ Region<?, ?> regionInThisCache = cache.getRegion(regionPath);
+ if (regionInThisCache != null) {// exists in local cache?
+ regionInThisCache.destroyRegion();
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__REGION_0_1_DESTROYED, new Object[] { regionPath, /*subRegionMessage*/"" });
+ xmlEntity = new XmlEntity(CacheXml.REGION, "name", regionName);
+ isRegionDestroyed = true;
+ }
+ DistributedMember distributedMember = cache.getDistributedSystem().getDistributedMember();
+ localRegionMembers.remove(distributedMember); //remove this member from the found members
+
+ CliFunctionResult destroyRegionResult = null;
+
+ ResultCollector<?, ?> resultCollector = CliUtil.executeFunction(RegionDestroyFunction.INSTANCE, regionPath, localRegionMembers);
+ List<CliFunctionResult> resultsList = (List<CliFunctionResult>) resultCollector.getResult();
+ for (int i = 0; i < resultsList.size(); i++) {
+ destroyRegionResult = resultsList.get(i) ;
+ if (destroyRegionResult.isSuccessful()) {
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__REGION_0_1_DESTROYED, new Object[] { regionPath, /*subRegionMessage*/"" });
+ xmlEntity = destroyRegionResult.getXmlEntity();
+ isRegionDestroyed = true;
+ } else if (destroyRegionResult.getThrowable() != null) {
+ Throwable t = destroyRegionResult.getThrowable();
+ LogWrapper.getInstance().info(t.getMessage(), t);
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__ERROR_OCCURRED_WHILE_DESTROYING_0_REASON_1,
+ new Object[] { regionPath, t.getMessage() });
+ isRegionDestroyed = false;
+ } else {
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__UNKNOWN_RESULT_WHILE_DESTROYING_REGION_0_REASON_1,
+ new Object[] { regionPath, destroyRegionResult.getMessage() });
+ isRegionDestroyed = false;
+ }
+ }
+ }
+ } else {
+ message = CliStrings.format(CliStrings.DESTROY_REGION__MSG__COULDNOT_FIND_REGIONPATH_0_IN_GEMFIRE, new Object[] { regionPath, "jmx-manager-update-rate milliseconds" });
+ isRegionDestroyed = false;
+ }
+ if (isRegionDestroyed) {
+ result = ResultBuilder.createInfoResult(message);
+ } else {
+ result = ResultBuilder.createUserErrorResult(message);
+ }
+ }
+ } else {
+ result = ResultBuilder.createInfoResult(CliStrings.DESTROY_REGION__MSG__SPECIFY_REGIONPATH_TO_DESTROY);
+ }
+ } catch (IllegalStateException e) {
+ result = ResultBuilder.createUserErrorResult(CliStrings.format(CliStrings.DESTROY_REGION__MSG__ERROR_WHILE_DESTROYING_REGION_0_REASON_1, new Object[] {regionPath, e.getMessage()}));
+ } catch (Exception e) {
+ result = ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.DESTROY_REGION__MSG__ERROR_WHILE_DESTROYING_REGION_0_REASON_1, new Object[] {regionPath, e.getMessage()}));
+ }
+
+ if (xmlEntity != null) {
+ result.setCommandPersisted((new SharedConfigurationWriter()).deleteXmlEntity(xmlEntity, null));
+ }
+ return result;
+ }
+
+ private Set<DistributedMember>[] findMembersForRegion(Cache cache, ManagementService managementService, String regionPath) {
+ Set<DistributedMember>[] membersList = null;
+ Set<String> regionMemberIds = Collections.emptySet();
+ Set<String> localRegionMemberIds = Collections.emptySet();
+ MBeanServer mbeanServer = MBeanJMXAdapter.mbeanServer;
+ String queryExp = MessageFormat.format(MBeanJMXAdapter.OBJECTNAME__REGION_MXBEAN, new Object[] {regionPath, "*"});
+ // String queryExp = MessageFormat.format(MBeanJMXAdapter.OBJECTNAME__REGION_MXBEAN, new Object[] {MBeanJMXAdapter.makeCompliantRegionNameAppender(regionPath), "*"});
+ try {
+ ObjectName queryExpON = new ObjectName(queryExp);
+ Set<ObjectName> queryNames = mbeanServer.queryNames(null, queryExpON);
+ if (queryNames != null && queryNames.size() != 0) {
+ regionMemberIds = new HashSet<String>();
+ localRegionMemberIds = new HashSet<String>();
+
+ membersList = (Set<DistributedMember>[])Array.newInstance(HashSet.class, 2);
+ }
+ for (ObjectName regionMBeanObjectName : queryNames) {
+ try {
+ RegionMXBean regionMXBean = managementService.getMBeanInstance(regionMBeanObjectName, RegionMXBean.class);
+ if (regionMXBean != null) {
+ RegionAttributesData regionAttributes = regionMXBean.listRegionAttributes();
+ String scope = regionAttributes.getScope();
+ if (Scope.LOCAL.equals(Scope.fromString(scope))) {
+ localRegionMemberIds.add(regionMXBean.getMember());
+ } else {
+ regionMemberIds.add(regionMXBean.getMember());
+ }
+ }
+ } catch (ClassCastException e) {
+ LogWriter logger = cache.getLogger();
+ if (logger.finerEnabled()) {
+ logger.finer(regionMBeanObjectName+" is not a "+RegionMXBean.class.getSimpleName(), e);
+ }
+ }
+ }
+ if (!regionMemberIds.isEmpty()) {
+ membersList[0] = getMembersByIds(cache, regionMemberIds);
+ }
+ if (!localRegionMemberIds.isEmpty()) {
+ membersList[1] = getMembersByIds(cache, localRegionMemberIds);
+ }
+
+ } catch (MalformedObjectNameException e) {
+ LogWrapper.getInstance().info(e.getMessage(), e);
+ } catch (NullPointerException e) {
+ LogWrapper.getInstance().info(e.getMessage(), e);
+ }
+
+ return membersList;
+ }
+
+ private Set<DistributedMember> getMembersByIds(Cache cache, Set<String> memberIds) {
+ Set<DistributedMember> foundMembers = Collections.emptySet();
+ if (memberIds != null && !memberIds.isEmpty()) {
+ foundMembers = new HashSet<DistributedMember>();
+ Set<DistributedMember> allNormalMembers = CliUtil.getAllNormalMembers(cache);
+
+ for (String memberId : memberIds) {
+ for (DistributedMember distributedMember : allNormalMembers) {
+ if (memberId.equals(distributedMember.getId()) || memberId.equals(distributedMember.getName())) {
+ foundMembers.add(distributedMember);
+ }
+ }
+ }
+ }
+ return foundMembers;
+ }
+
+ @CliAvailabilityIndicator({ CliStrings.ALTER_REGION, CliStrings.CREATE_REGION, CliStrings.DESTROY_REGION })
+ public boolean isRegionCommandAvailable() {
+ boolean isAvailable = true; // always available on server
+ if (CliUtil.isGfshVM()) { // in gfsh check if connected //TODO - Abhishek: make this better
+ isAvailable = getGfsh() != null && getGfsh().isConnectedAndReady();
+ }
+ return isAvailable;
+ }
+ }