com.gemstone.gemfire.management.internal.cli.commands.DiskStoreCommands Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
Show all versions of gemfire-core Show documentation
SnappyData store based off Pivotal GemFireXD
The newest version!
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed 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. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.management.internal.cli.commands;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
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 com.gemstone.gemfire.GemFireIOException;
import com.gemstone.gemfire.SystemFailure;
import com.gemstone.gemfire.admin.BackupStatus;
import com.gemstone.gemfire.admin.internal.AdminDistributedSystemImpl;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.cache.CacheExistsException;
import com.gemstone.gemfire.cache.CacheFactory;
import com.gemstone.gemfire.cache.Region;
import com.gemstone.gemfire.cache.execute.Execution;
import com.gemstone.gemfire.cache.execute.FunctionInvocationTargetException;
import com.gemstone.gemfire.cache.execute.ResultCollector;
import com.gemstone.gemfire.cache.persistence.PersistentID;
import com.gemstone.gemfire.distributed.DistributedMember;
import com.gemstone.gemfire.distributed.internal.DM;
import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
import com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember;
import com.gemstone.gemfire.internal.cache.DiskStoreAttributes;
import com.gemstone.gemfire.internal.cache.DiskStoreImpl;
import com.gemstone.gemfire.internal.cache.GemFireCacheImpl;
import com.gemstone.gemfire.internal.cache.execute.AbstractExecution;
import com.gemstone.gemfire.internal.lang.ClassUtils;
import com.gemstone.gemfire.management.DistributedSystemMXBean;
import com.gemstone.gemfire.management.ManagementService;
import com.gemstone.gemfire.management.PersistentMemberDetails;
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.cli.CliUtil;
import com.gemstone.gemfire.management.internal.cli.GfshParser;
import com.gemstone.gemfire.management.internal.cli.LogWrapper;
import com.gemstone.gemfire.management.internal.cli.domain.DiskStoreDetails;
import com.gemstone.gemfire.management.internal.cli.functions.CliFunctionResult;
import com.gemstone.gemfire.management.internal.cli.functions.CreateDiskStoreFunction;
import com.gemstone.gemfire.management.internal.cli.functions.DescribeDiskStoreFunction;
import com.gemstone.gemfire.management.internal.cli.functions.DestroyDiskStoreFunction;
import com.gemstone.gemfire.management.internal.cli.functions.ListDiskStoresFunction;
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.CompositeResultData;
import com.gemstone.gemfire.management.internal.cli.result.CompositeResultData.SectionResultData;
import com.gemstone.gemfire.management.internal.cli.result.ErrorResultData;
import com.gemstone.gemfire.management.internal.cli.result.ResultBuilder;
import com.gemstone.gemfire.management.internal.cli.result.ResultDataException;
import com.gemstone.gemfire.management.internal.cli.result.TabularResultData;
import com.gemstone.gemfire.management.internal.cli.shell.Gfsh;
import com.gemstone.gemfire.management.internal.cli.util.DiskStoreCompacter;
import com.gemstone.gemfire.management.internal.cli.util.DiskStoreNotFoundException;
import com.gemstone.gemfire.management.internal.cli.util.DiskStoreUpgrader;
import com.gemstone.gemfire.management.internal.cli.util.DiskStoreValidater;
import com.gemstone.gemfire.management.internal.cli.util.MemberNotFoundException;
import com.gemstone.gemfire.management.internal.messages.CompactRequest;
import org.springframework.shell.core.annotation.CliAvailabilityIndicator;
import org.springframework.shell.core.annotation.CliCommand;
import org.springframework.shell.core.annotation.CliOption;
/**
* The DiskStoreCommands class encapsulates all GemFire Disk Store commands in Gfsh.
*
* @author Nikhil Jadhav
* @author John Blum
* @author Abhishek Chaudhari
* @author Sourabh Bansod
* @author David Hoots
* @see com.gemstone.gemfire.management.internal.cli.commands.AbstractCommandsSupport
* @since 7.0
*/
@SuppressWarnings("unused")
public class DiskStoreCommands extends AbstractCommandsSupport {
@Override
protected Set getMembers(final Cache cache) {
// TODO determine what this does (as it is untested and unmockable!)
return CliUtil.getAllMembers(cache);
}
@CliCommand(value=CliStrings.BACKUP_DISK_STORE, help=CliStrings.BACKUP_DISK_STORE__HELP)
@CliMetaData(relatedTopic={ CliStrings.TOPIC_GEMFIRE_DISKSTORE })
public Result backupDiskStore(
@CliOption(key=CliStrings.BACKUP_DISK_STORE__DISKDIRS,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.BACKUP_DISK_STORE__DISKDIRS__HELP,
mandatory = true)
String targetDir,
@CliOption(key=CliStrings.BACKUP_DISK_STORE__BASELINEDIR,
help=CliStrings.BACKUP_DISK_STORE__BASELINEDIR__HELP)
String baselineDir){
Result result = null;
try {
GemFireCacheImpl cache = (GemFireCacheImpl)CacheFactory.getAnyInstance();
DM dm = cache.getDistributionManager();
BackupStatus backupStatus = null;
if (baselineDir != null && !baselineDir.isEmpty()) {
backupStatus = AdminDistributedSystemImpl.backupAllMembers(dm, new File(targetDir), new File(baselineDir));
} else {
backupStatus = AdminDistributedSystemImpl.backupAllMembers(dm, new File(targetDir), null);
}
Map> backedupMemberDiskstoreMap = backupStatus.getBackedUpDiskStores();
Set backedupMembers = backedupMemberDiskstoreMap.keySet();
CompositeResultData crd = ResultBuilder.createCompositeResultData();
if (!backedupMembers.isEmpty()) {
SectionResultData backedupDiskStoresSection = crd.addSection();
backedupDiskStoresSection.setHeader(CliStrings.BACKUP_DISK_STORE_MSG_BACKED_UP_DISK_STORES);
TabularResultData backedupDiskStoresTable = backedupDiskStoresSection.addTable();
for (DistributedMember member : backedupMembers) {
Set backedupDiskStores = backedupMemberDiskstoreMap.get(member);
boolean printMember = true;
String memberName = member.getName();
if (memberName == null || memberName.isEmpty()) {
memberName = member.getId();
}
for (PersistentID persistentId : backedupDiskStores) {
if (persistentId != null) {
String UUID = persistentId.getUUID().toString();
String hostName = persistentId.getHost().getHostName();
String directory = persistentId.getDirectory();
if (printMember) {
writeToBackupDisktoreTable(backedupDiskStoresTable, memberName, UUID, hostName, directory);
printMember = false;
} else {
writeToBackupDisktoreTable(backedupDiskStoresTable, "", UUID, hostName, directory);
}
}
}
}
} else {
SectionResultData noMembersBackedUp = crd.addSection();
noMembersBackedUp.setHeader(CliStrings.BACKUP_DISK_STORE_MSG_NO_DISKSTORES_BACKED_UP);
}
Set offlineDiskStores = backupStatus.getOfflineDiskStores();
if (!offlineDiskStores.isEmpty()) {
SectionResultData offlineDiskStoresSection = crd.addSection();
TabularResultData offlineDiskStoresTable = offlineDiskStoresSection.addTable();
offlineDiskStoresSection.setHeader(CliStrings.BACKUP_DISK_STORE_MSG_OFFLINE_DISK_STORES);
for (PersistentID offlineDiskStore : offlineDiskStores) {
offlineDiskStoresTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_UUID, offlineDiskStore.getUUID().toString());
offlineDiskStoresTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_HOST, offlineDiskStore.getHost().getHostName());
offlineDiskStoresTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_DIRECTORY, offlineDiskStore.getDirectory());
}
}
result = ResultBuilder.buildResult(crd);
} catch (Exception e) {
result = ResultBuilder.createGemFireErrorResult(e.getMessage());
}
return result;
}
private void writeToBackupDisktoreTable(TabularResultData backedupDiskStoreTable, String memberId, String UUID, String host, String directory) {
backedupDiskStoreTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_MEMBER, memberId);
backedupDiskStoreTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_UUID, UUID);
backedupDiskStoreTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_DIRECTORY, directory);
backedupDiskStoreTable.accumulate(CliStrings.BACKUP_DISK_STORE_MSG_HOST, host);
}
@CliCommand(value = CliStrings.LIST_DISK_STORE, help = CliStrings.LIST_DISK_STORE__HELP)
@CliMetaData(shellOnly = false, relatedTopic = { CliStrings.TOPIC_GEMFIRE_DISKSTORE })
public Result listDiskStore() {
try {
return toTabularResult(getDiskStoreListing());
}
catch (FunctionInvocationTargetException ignore) {
return ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.COULD_NOT_EXECUTE_COMMAND_TRY_AGAIN,
CliStrings.LIST_DISK_STORE));
}
catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
}
catch (Throwable t) {
SystemFailure.checkFailure();
return ResultBuilder.createGemFireErrorResult(String.format(CliStrings.LIST_DISK_STORE__ERROR_MESSAGE,
toString(t, isDebugging())));
}
}
@SuppressWarnings("unchecked")
protected List getDiskStoreListing() {
final Execution membersFunctionExecutor = getMembersFunctionExecutor(getMembers(getCache()));
if (membersFunctionExecutor instanceof AbstractExecution) {
((AbstractExecution) membersFunctionExecutor).setIgnoreDepartedMembers(true);
}
final ResultCollector resultCollector = membersFunctionExecutor.execute(new ListDiskStoresFunction());
final List results = (List) resultCollector.getResult();
final List distributedSystemMemberDiskStores = new ArrayList(results.size());
for (final Object result : results) {
if (result instanceof Set) { // ignore FunctionInvocationTargetExceptions and other Exceptions...
distributedSystemMemberDiskStores.addAll((Set) result);
}
}
Collections.sort(distributedSystemMemberDiskStores);
return distributedSystemMemberDiskStores;
}
protected Result toTabularResult(final List diskStoreList) throws ResultDataException {
if (!diskStoreList.isEmpty()) {
final TabularResultData diskStoreData = ResultBuilder.createTabularResultData();
for (final DiskStoreDetails diskStoreDetails : diskStoreList) {
diskStoreData.accumulate("Member Name", diskStoreDetails.getMemberName());
diskStoreData.accumulate("Member Id", diskStoreDetails.getMemberId());
diskStoreData.accumulate("Disk Store Name", diskStoreDetails.getName());
diskStoreData.accumulate("Disk Store ID", diskStoreDetails.getId());
}
return ResultBuilder.buildResult(diskStoreData);
}
else {
return ResultBuilder.createInfoResult(CliStrings.LIST_DISK_STORE__DISK_STORES_NOT_FOUND_MESSAGE);
}
}
@CliCommand(value=CliStrings.CREATE_DISK_STORE, help=CliStrings.CREATE_DISK_STORE__HELP)
@CliMetaData(shellOnly=false, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result createDiskStore(@CliOption(key=CliStrings.CREATE_DISK_STORE__NAME,
mandatory=true,
optionContext = ConverterHint.DISKSTORE_ALL,
help=CliStrings.CREATE_DISK_STORE__NAME__HELP)
String name,
@CliOption(key=CliStrings.CREATE_DISK_STORE__ALLOW_FORCE_COMPACTION,
specifiedDefaultValue = "true",
unspecifiedDefaultValue = "false",
help=CliStrings.CREATE_DISK_STORE__ALLOW_FORCE_COMPACTION__HELP)
boolean allowForceCompaction,
@CliOption(key=CliStrings.CREATE_DISK_STORE__AUTO_COMPACT,
specifiedDefaultValue = "true",
unspecifiedDefaultValue = "true",
help=CliStrings.CREATE_DISK_STORE__AUTO_COMPACT__HELP)
boolean autoCompact,
@CliOption(key=CliStrings.CREATE_DISK_STORE__COMPACTION_THRESHOLD,
unspecifiedDefaultValue="50",
help=CliStrings.CREATE_DISK_STORE__COMPACTION_THRESHOLD__HELP)
int compactionThreshold,
@CliOption(key=CliStrings.CREATE_DISK_STORE__MAX_OPLOG_SIZE,
unspecifiedDefaultValue="1024",
help=CliStrings.CREATE_DISK_STORE__MAX_OPLOG_SIZE__HELP)
int maxOplogSize,
@CliOption(key=CliStrings.CREATE_DISK_STORE__QUEUE_SIZE,
unspecifiedDefaultValue="0",
help=CliStrings.CREATE_DISK_STORE__QUEUE_SIZE__HELP)
int queueSize,
@CliOption(key=CliStrings.CREATE_DISK_STORE__TIME_INTERVAL,
unspecifiedDefaultValue="1000",
help=CliStrings.CREATE_DISK_STORE__TIME_INTERVAL__HELP)
long timeInterval,
@CliOption(key=CliStrings.CREATE_DISK_STORE__WRITE_BUFFER_SIZE,
unspecifiedDefaultValue="32768",
help=CliStrings.CREATE_DISK_STORE__WRITE_BUFFER_SIZE__HELP)
int writeBufferSize,
@CliOption(key=CliStrings.CREATE_DISK_STORE__DIRECTORY_AND_SIZE,
mandatory=true,
help=CliStrings.CREATE_DISK_STORE__DIRECTORY_AND_SIZE__HELP,
optionContext=ConverterHint.STRING_DISABLER)
@CliMetaData (valueSeparator = ",")
String[] directoriesAndSizes,
@CliOption(key=CliStrings.CREATE_DISK_STORE__GROUP,
help=CliStrings.CREATE_DISK_STORE__GROUP__HELP,
optionContext=ConverterHint.MEMBERGROUP)
@CliMetaData (valueSeparator = ",")
String group) {
try {
DiskStoreAttributes diskStoreAttributes = new DiskStoreAttributes();
diskStoreAttributes.allowForceCompaction = allowForceCompaction;
diskStoreAttributes.autoCompact = autoCompact;
diskStoreAttributes.compactionThreshold = compactionThreshold;
diskStoreAttributes.setMaxOplogSizeInBytes(maxOplogSize * (1024*1024));
diskStoreAttributes.queueSize = queueSize;
diskStoreAttributes.timeInterval = timeInterval;
diskStoreAttributes.writeBufferSize = writeBufferSize;
File[] directories = new File[directoriesAndSizes.length];
int[] sizes = new int[directoriesAndSizes.length];
for (int i = 0; i < directoriesAndSizes.length; i++) {
final int hashPosition = directoriesAndSizes[i].indexOf('#');
if (hashPosition == -1) {
directories[i] = new File(directoriesAndSizes[i]);
sizes[i] = Integer.MAX_VALUE;
} else {
directories[i] = new File(directoriesAndSizes[i].substring(0, hashPosition));
sizes[i] = Integer.parseInt(directoriesAndSizes[i].substring(hashPosition + 1));
}
}
diskStoreAttributes.diskDirs = directories;
diskStoreAttributes.diskDirSizes = sizes;
TabularResultData tabularData = ResultBuilder.createTabularResultData();
boolean accumulatedData = false;
Set targetMembers;
try {
targetMembers = CliUtil.findAllMatchingMembers(group, null);
} catch (CommandResultException crex) {
return crex.getResult();
}
ResultCollector rc = CliUtil.executeFunction(new CreateDiskStoreFunction(), new Object[] { name, diskStoreAttributes },
targetMembers);
List results = CliFunctionResult.cleanResults((List) rc.getResult());
for (CliFunctionResult result : results) {
if (result.getThrowable() != null) {
tabularData.accumulate("Member", result.getMemberIdOrName());
tabularData.accumulate("Result", "ERROR: " + result.getThrowable().getClass().getName() + ": "
+ result.getThrowable().getMessage());
accumulatedData = true;
tabularData.setStatus(Status.ERROR);
} else if (result.isSuccessful()) {
tabularData.accumulate("Member", result.getMemberIdOrName());
tabularData.accumulate("Result", result.getMessage());
accumulatedData = true;
}
}
if (!accumulatedData) {
return ResultBuilder.createInfoResult("Unable to create disk store(s).");
}
return ResultBuilder.buildResult(tabularData);
} catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
} catch (Throwable th) {
SystemFailure.checkFailure();
return ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.CREATE_DISK_STORE__ERROR_WHILE_CREATING_REASON_0,
new Object[] { th.getMessage() }));
}
}
@CliCommand(value=CliStrings.COMPACT_DISK_STORE, help=CliStrings.COMPACT_DISK_STORE__HELP)
@CliMetaData(shellOnly=false, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result compactDiskStore(@CliOption(key=CliStrings.COMPACT_DISK_STORE__NAME,
mandatory=true,
optionContext = ConverterHint.DISKSTORE_ALL,
help=CliStrings.COMPACT_DISK_STORE__NAME__HELP)
String diskStoreName,
@CliOption(key=CliStrings.COMPACT_DISK_STORE__GROUP,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.COMPACT_DISK_STORE__GROUP__HELP,
optionContext=ConverterHint.STRING_DISABLER)
@CliMetaData (valueSeparator = ",")
String[] groups) {
Result result = null;
try {
// disk store exists validation
if (!diskStoreExists(diskStoreName)) {
result = ResultBuilder.createUserErrorResult(CliStrings.format(CliStrings.COMPACT_DISK_STORE__DISKSTORE_0_DOESNOT_EXIST, new Object[] {diskStoreName}));
} else {
InternalDistributedSystem ds = (InternalDistributedSystem)getCache().getDistributedSystem();
Map overallCompactInfo = new HashMap();
Set otherMembers = ds.getDistributionManager().getOtherNormalDistributionManagerIds();
Set allMembers = new HashSet();
for (Object member : otherMembers) {
allMembers.add((InternalDistributedMember) member);
}
allMembers.add(ds.getDistributedMember());
otherMembers = null;
String groupInfo = "";
// if groups are specified, find members in the specified group
if (groups != null && groups.length > 0) {
groupInfo = CliStrings.format(CliStrings.COMPACT_DISK_STORE__MSG__FOR_GROUP, new Object[] {Arrays.toString(groups) + "."});
final Set selectedMembers = new HashSet();
List targetedGroups = Arrays.asList(groups);
for (Iterator iterator = allMembers.iterator(); iterator.hasNext();) {
InternalDistributedMember member = iterator.next();
List memberGroups = member.getGroups();
if (!Collections.disjoint(targetedGroups, memberGroups)) {
selectedMembers.add(member);
}
}
allMembers = selectedMembers;
}
// allMembers should not be empty when groups are not specified - it'll
// have at least one member
if (allMembers.isEmpty()) {
result = ResultBuilder.createUserErrorResult(CliStrings.format(CliStrings.COMPACT_DISK_STORE__NO_MEMBERS_FOUND_IN_SPECIFED_GROUP, new Object[] {Arrays.toString(groups)}));
} else {
// first invoke on local member if it exists in the targeted set
if (allMembers.remove(ds.getDistributedMember())) {
PersistentID compactedDiskStoreId = CompactRequest.compactDiskStore(diskStoreName);
if (compactedDiskStoreId != null) {
overallCompactInfo.put(ds.getDistributedMember(), compactedDiskStoreId);
}
}
// was this local member the only one? Then don't try to send
// CompactRequest. Otherwise, send the request to others
if (!allMembers.isEmpty()) {
// Invoke compact on all 'other' members
Map memberCompactInfo = CompactRequest.send(ds.getDistributionManager(), diskStoreName, allMembers);
if (memberCompactInfo != null && !memberCompactInfo.isEmpty()) {
overallCompactInfo.putAll(memberCompactInfo);
memberCompactInfo.clear();
}
String notExecutedMembers = CompactRequest.getNotExecutedMembers();
LogWrapper.getInstance().info("compact disk-store \""+diskStoreName+"\" message was scheduled to be sent to but was not send to "+notExecutedMembers);
}
// If compaction happened at all, then prepare the summary
if (overallCompactInfo != null && !overallCompactInfo.isEmpty()) {
CompositeResultData compositeResultData = ResultBuilder.createCompositeResultData();
SectionResultData section = null;
Set> entries = overallCompactInfo.entrySet();
for (Entry entry : entries) {
String memberId = entry.getKey().getId();
section = compositeResultData.addSection(memberId);
section.addData("On Member", memberId);
PersistentID persistentID = entry.getValue();
if (persistentID != null) {
SectionResultData subSection = section.addSection("DiskStore"+memberId);
subSection.addData("UUID", persistentID.getUUID());
subSection.addData("Host", persistentID.getHost().getHostName());
subSection.addData("Directory", persistentID.getDirectory());
}
}
compositeResultData.setHeader("Compacted " + diskStoreName + groupInfo);
result = ResultBuilder.buildResult(compositeResultData);
} else {
result = ResultBuilder.createInfoResult(CliStrings.COMPACT_DISK_STORE__COMPACTION_ATTEMPTED_BUT_NOTHING_TO_COMPACT);
}
} // all members' if
} // disk store exists' if
} catch (RuntimeException e) {
LogWrapper.getInstance().info(e.getMessage(), e);
result = ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.COMPACT_DISK_STORE__ERROR_WHILE_COMPACTING_REASON_0, new Object[] {e.getMessage()}));
}
return result;
}
private boolean diskStoreExists(String diskStoreName) {
Cache cache = getCache();
ManagementService managementService = ManagementService.getExistingManagementService(cache);
DistributedSystemMXBean dsMXBean = managementService.getDistributedSystemMXBean();
Map diskstore = dsMXBean.listMemberDiskstore();
Set> entrySet = diskstore.entrySet();
for (Entry entry : entrySet) {
String[] value = entry.getValue();
if (CliUtil.contains(value, diskStoreName)) {
return true;
}
}
return false;
}
@CliCommand(value=CliStrings.COMPACT_OFFLINE_DISK_STORE, help=CliStrings.COMPACT_OFFLINE_DISK_STORE__HELP)
@CliMetaData(shellOnly=true, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result compactOfflineDiskStore(
@CliOption(key=CliStrings.COMPACT_OFFLINE_DISK_STORE__NAME,
mandatory=true,
help=CliStrings.COMPACT_OFFLINE_DISK_STORE__NAME__HELP)
String diskStoreName,
@CliOption(key=CliStrings.COMPACT_OFFLINE_DISK_STORE__DISKDIRS,
mandatory=true,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.COMPACT_OFFLINE_DISK_STORE__DISKDIRS__HELP,
optionContext=ConverterHint.DIRS+":"+ConverterHint.STRING_DISABLER)
@CliMetaData (valueSeparator = ",")
String[] diskDirs,
@CliOption(key=CliStrings.COMPACT_OFFLINE_DISK_STORE__MAXOPLOGSIZE,
unspecifiedDefaultValue="-1",
help=CliStrings.COMPACT_OFFLINE_DISK_STORE__MAXOPLOGSIZE__HELP)
long maxOplogSize,
@CliOption(key=CliStrings.COMPACT_OFFLINE_DISK_STORE__J,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.COMPACT_OFFLINE_DISK_STORE__J__HELP)
@CliMetaData (valueSeparator = ",")
String[] jvmProps) {
Result result = null;
LogWrapper logWrapper = LogWrapper.getInstance();
StringBuilder output = new StringBuilder();
StringBuilder error = new StringBuilder();
String errorMessage = "";
Process compacterProcess = null;
try {
String validatedDirectories = validatedDirectories(diskDirs);
if (validatedDirectories != null) {
throw new IllegalArgumentException("Could not find "+CliStrings.COMPACT_OFFLINE_DISK_STORE__DISKDIRS + ": \""+validatedDirectories+"\"");
}
List commandList = new ArrayList();
commandList.add(System.getProperty("java.home") + File.separatorChar + "bin"+ File.separatorChar + "java");
if (jvmProps != null && jvmProps.length != 0) {
for (int i = 0; i < jvmProps.length; i++) {
commandList.add(jvmProps[i]);
}
}
commandList.add("-classpath");
commandList.add(System.getProperty("java.class.path", "."));
commandList.add(DiskStoreCompacter.class.getName());
commandList.add(CliStrings.COMPACT_OFFLINE_DISK_STORE__NAME+"="+diskStoreName);
if (diskDirs != null && diskDirs.length != 0) {
StringBuilder builder = new StringBuilder();
int arrayLength = diskDirs.length;
for (int i = 0; i < arrayLength; i++) {
if (File.separatorChar == '\\') {
builder.append(diskDirs[i].replace("\\", "/")); // see 46120
} else {
builder.append(diskDirs[i]);
}
if (i + 1 != arrayLength) {
builder.append(',');
}
}
commandList.add(CliStrings.COMPACT_OFFLINE_DISK_STORE__DISKDIRS+"="+builder.toString());
}
// -1 is ignore as maxOplogSize
commandList.add(CliStrings.COMPACT_OFFLINE_DISK_STORE__MAXOPLOGSIZE+"="+maxOplogSize);
ProcessBuilder procBuilder = new ProcessBuilder(commandList);
compacterProcess = procBuilder.start();
InputStream inputStream = compacterProcess.getInputStream();
InputStream errorStream = compacterProcess.getErrorStream();
BufferedReader inputReader = new BufferedReader(new InputStreamReader(inputStream));
BufferedReader errorReader = new BufferedReader(new InputStreamReader(errorStream));
String line = null;
while ((line = inputReader.readLine()) != null) {
output.append(line).append(GfshParser.LINE_SEPARATOR);
}
line = null;
boolean switchToStackTrace = false;
while ((line = errorReader.readLine()) != null) {
if (!switchToStackTrace && DiskStoreCompacter.STACKTRACE_START.equals(line)) {
switchToStackTrace = true;
} else if (switchToStackTrace) {
error.append(line).append(GfshParser.LINE_SEPARATOR);
} else {
errorMessage = errorMessage + line;
}
}
if (!errorMessage.isEmpty()) {
throw new GemFireIOException(errorMessage);
}
// do we have to waitFor??
compacterProcess.destroy();
result = ResultBuilder.createInfoResult(output.toString());
} catch (IOException e) {
if (output.length() != 0) {
Gfsh.println(output.toString());
}
String fieldsMessage = (maxOplogSize != -1 ? CliStrings.COMPACT_OFFLINE_DISK_STORE__MAXOPLOGSIZE + "=" +maxOplogSize + "," : "");
fieldsMessage += CliUtil.arrayToString(diskDirs);
String errorString = CliStrings.format(CliStrings.COMPACT_OFFLINE_DISK_STORE__MSG__ERROR_WHILE_COMPACTING_DISKSTORE_0_WITH_1_REASON_2, new Object[] {diskStoreName, fieldsMessage});
result = ResultBuilder.createUserErrorResult(errorString);
if (logWrapper.fineEnabled()) {
logWrapper.fine(e.getMessage(), e);
}
} catch (GemFireIOException e) {
if (output.length() != 0) {
Gfsh.println(output.toString());
}
result = ResultBuilder.createUserErrorResult(errorMessage);
if (logWrapper.fineEnabled()) {
logWrapper.fine(error.toString());
}
} catch (IllegalArgumentException e) {
if (output.length() != 0) {
Gfsh.println(output.toString());
}
result = ResultBuilder.createUserErrorResult(e.getMessage());
} finally {
if (compacterProcess != null) {
try {
// just to check whether the process has exited
// Process.exitValue() throws IllegalThreadStateException if Process
// is alive
compacterProcess.exitValue();
} catch (IllegalThreadStateException ise) {
// not yet terminated, destroy the process
compacterProcess.destroy();
}
}
}
return result;
}
@CliCommand(value=CliStrings.UPGRADE_OFFLINE_DISK_STORE, help=CliStrings.UPGRADE_OFFLINE_DISK_STORE__HELP)
@CliMetaData(shellOnly=true, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result upgradeOfflineDiskStore(
@CliOption(key=CliStrings.UPGRADE_OFFLINE_DISK_STORE__NAME,
mandatory=true,
help=CliStrings.UPGRADE_OFFLINE_DISK_STORE__NAME__HELP)
String diskStoreName,
@CliOption(key=CliStrings.UPGRADE_OFFLINE_DISK_STORE__DISKDIRS,
mandatory=true,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.UPGRADE_OFFLINE_DISK_STORE__DISKDIRS__HELP,
optionContext=ConverterHint.DIRS+":"+ConverterHint.STRING_DISABLER)
@CliMetaData (valueSeparator = ",")
String[] diskDirs,
@CliOption(key=CliStrings.UPGRADE_OFFLINE_DISK_STORE__MAXOPLOGSIZE,
unspecifiedDefaultValue="-1",
help=CliStrings.UPGRADE_OFFLINE_DISK_STORE__MAXOPLOGSIZE__HELP)
long maxOplogSize,
@CliOption(key=CliStrings.UPGRADE_OFFLINE_DISK_STORE__J,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.UPGRADE_OFFLINE_DISK_STORE__J__HELP)
@CliMetaData (valueSeparator = ",")
String[] jvmProps) throws InterruptedException {
Result result = null;
LogWrapper logWrapper = LogWrapper.getInstance();
StringBuilder output = new StringBuilder();
StringBuilder error = new StringBuilder();
String errorMessage = "";
Process upgraderProcess = null;
try {
String validatedDirectories = validatedDirectories(diskDirs);
if (validatedDirectories != null) {
throw new IllegalArgumentException("Could not find "+CliStrings.UPGRADE_OFFLINE_DISK_STORE__DISKDIRS + ": \""+validatedDirectories+"\"");
}
List commandList = new ArrayList();
commandList.add(System.getProperty("java.home") + File.separatorChar + "bin"+ File.separatorChar + "java");
if (jvmProps != null && jvmProps.length != 0) {
for (int i = 0; i < jvmProps.length; i++) {
commandList.add(jvmProps[i]);
}
}
commandList.add("-classpath");
commandList.add(System.getProperty("java.class.path", "."));
commandList.add(DiskStoreUpgrader.class.getName());
commandList.add(CliStrings.UPGRADE_OFFLINE_DISK_STORE__NAME+"="+diskStoreName);
if (diskDirs != null && diskDirs.length != 0) {
StringBuilder builder = new StringBuilder();
int arrayLength = diskDirs.length;
for (int i = 0; i < arrayLength; i++) {
if (File.separatorChar == '\\') {
builder.append(diskDirs[i].replace("\\", "/")); // see 46120
} else {
builder.append(diskDirs[i]);
}
if (i + 1 != arrayLength) {
builder.append(',');
}
}
commandList.add(CliStrings.UPGRADE_OFFLINE_DISK_STORE__DISKDIRS+"="+builder.toString());
}
// -1 is ignore as maxOplogSize
commandList.add(CliStrings.UPGRADE_OFFLINE_DISK_STORE__MAXOPLOGSIZE+"="+maxOplogSize);
ProcessBuilder procBuilder = new ProcessBuilder(commandList);
//procBuilder.redirectErrorStream(true);
upgraderProcess = procBuilder.start();
InputStream inputStream = upgraderProcess.getInputStream();
InputStream errorStream = upgraderProcess.getErrorStream();
BufferedReader inputReader = new BufferedReader(new InputStreamReader(inputStream));
BufferedReader errorReader = new BufferedReader(new InputStreamReader(errorStream));
String line = null;
while ((line = inputReader.readLine()) != null) {
output.append(line).append(GfshParser.LINE_SEPARATOR);
}
line = null;
boolean switchToStackTrace = false;
while ((line = errorReader.readLine()) != null) {
if (!switchToStackTrace && DiskStoreUpgrader.STACKTRACE_START.equals(line)) {
switchToStackTrace = true;
} else if (switchToStackTrace) {
error.append(line).append(GfshParser.LINE_SEPARATOR);
} else {
errorMessage = errorMessage + line;
}
}
if (!errorMessage.isEmpty()) {
throw new GemFireIOException(errorMessage);
}
// do we have to waitFor??
//upgraderProcess.waitFor();
upgraderProcess.destroy();
result = ResultBuilder.createInfoResult(output.toString());
} catch (IOException e) {
if (output.length() != 0) {
Gfsh.println(output.toString());
}
String fieldsMessage = (maxOplogSize != -1 ? CliStrings.UPGRADE_OFFLINE_DISK_STORE__MAXOPLOGSIZE + "=" +maxOplogSize + "," : "");
fieldsMessage += CliUtil.arrayToString(diskDirs);
String errorString = CliStrings.format(CliStrings.UPGRADE_OFFLINE_DISK_STORE__MSG__ERROR_WHILE_COMPACTING_DISKSTORE_0_WITH_1_REASON_2, new Object[] {diskStoreName, fieldsMessage});
result = ResultBuilder.createUserErrorResult(errorString);
if (logWrapper.fineEnabled()) {
logWrapper.fine(e.getMessage(), e);
}
} catch (GemFireIOException e) {
if (output.length() != 0) {
Gfsh.println(output.toString());
}
result = ResultBuilder.createUserErrorResult(errorMessage);
if (logWrapper.fineEnabled()) {
logWrapper.fine(error.toString());
}
} catch (IllegalArgumentException e) {
if (output.length() != 0) {
Gfsh.println(output.toString());
}
result = ResultBuilder.createUserErrorResult(e.getMessage());
} finally {
if (upgraderProcess != null) {
try {
// just to check whether the process has exited
// Process.exitValue() throws IllegalStateException if Process is alive
upgraderProcess.exitValue();
} catch (IllegalThreadStateException itse) {
// not yet terminated, destroy the process
upgraderProcess.destroy();
}
}
}
return result;
}
private String validatedDirectories(String[] diskDirs) {
String invalidDirectories = null;
StringBuilder builder = null;
File diskDir = null;
for (String diskDirPath : diskDirs) {
diskDir = new File(diskDirPath);
if (!diskDir.exists()) {
if (builder == null) {
builder = new StringBuilder();
} else if (builder.length() != 0) {
builder.append(", ");
}
builder.append(diskDirPath);
}
}
if (builder != null) {
invalidDirectories = builder.toString();
}
return invalidDirectories;
}
@CliCommand(value = CliStrings.DESCRIBE_DISK_STORE, help = CliStrings.DESCRIBE_DISK_STORE__HELP)
@CliMetaData(shellOnly = false, relatedTopic = { CliStrings.TOPIC_GEMFIRE_DISKSTORE })
public Result describeDiskStore(@CliOption(key = CliStrings.DESCRIBE_DISK_STORE__MEMBER, mandatory = true, optionContext = ConverterHint.MEMBERIDNAME, help = CliStrings.DESCRIBE_DISK_STORE__MEMBER__HELP)
final String memberName,
@CliOption(key = CliStrings.DESCRIBE_DISK_STORE__NAME, mandatory = true, optionContext = ConverterHint.DISKSTORE_ALL, help = CliStrings.DESCRIBE_DISK_STORE__NAME__HELP)
final String diskStoreName) {
try {
return toCompositeResult(getDiskStoreDescription(memberName, diskStoreName));
}
catch (DiskStoreNotFoundException e) {
return ResultBuilder.createShellClientErrorResult(e.getMessage());
}
catch (MemberNotFoundException e) {
return ResultBuilder.createShellClientErrorResult(e.getMessage());
}
catch (FunctionInvocationTargetException ignore) {
return ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.COULD_NOT_EXECUTE_COMMAND_TRY_AGAIN,
CliStrings.DESCRIBE_DISK_STORE));
}
catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
}
catch (Throwable t) {
SystemFailure.checkFailure();
return ResultBuilder.createGemFireErrorResult(String.format(CliStrings.DESCRIBE_DISK_STORE__ERROR_MESSAGE,
memberName, diskStoreName, toString(t, isDebugging())));
}
}
protected DiskStoreDetails getDiskStoreDescription(final String memberName, final String diskStoreName) {
final DistributedMember member = getMember(getCache(), memberName); // may throw a MemberNotFoundException
final ResultCollector resultCollector = getMembersFunctionExecutor(Collections.singleton(member))
.withArgs(diskStoreName).execute(new DescribeDiskStoreFunction());
final Object result = ((List) resultCollector.getResult()).get(0);
if (result instanceof DiskStoreDetails) { // disk store details in hand...
return (DiskStoreDetails) result;
}
else if (result instanceof DiskStoreNotFoundException) { // bad disk store name...
throw (DiskStoreNotFoundException) result;
}
else { // unknown and unexpected return type...
final Throwable cause = (result instanceof Throwable ? (Throwable) result : null);
if (isLogging()) {
if (cause != null) {
getGfsh().logSevere(String.format(
"Exception (%1$s) occurred while executing '%2$s' on member (%3$s) with disk store (%4$s).",
ClassUtils.getClassName(cause), CliStrings.DESCRIBE_DISK_STORE, memberName, diskStoreName), cause);
}
else {
getGfsh().logSevere(String.format(
"Received an unexpected result of type (%1$s) while executing '%2$s' on member (%3$s) with disk store (%4$s).",
ClassUtils.getClassName(result), CliStrings.DESCRIBE_DISK_STORE, memberName, diskStoreName), null);
}
}
throw new RuntimeException(CliStrings.format(CliStrings.UNEXPECTED_RETURN_TYPE_EXECUTING_COMMAND_ERROR_MESSAGE,
ClassUtils.getClassName(result), CliStrings.DESCRIBE_DISK_STORE), cause);
}
}
protected Result toCompositeResult(final DiskStoreDetails diskStoreDetails) {
final CompositeResultData diskStoreData = ResultBuilder.createCompositeResultData();
final CompositeResultData.SectionResultData diskStoreSection = diskStoreData.addSection();
diskStoreSection.addData("Disk Store ID", diskStoreDetails.getId());
diskStoreSection.addData("Disk Store Name", diskStoreDetails.getName());
diskStoreSection.addData("Member ID", diskStoreDetails.getMemberId());
diskStoreSection.addData("Member Name", diskStoreDetails.getMemberName());
diskStoreSection.addData("Allow Force Compaction", toString(diskStoreDetails.isAllowForceCompaction(), "Yes", "No"));
diskStoreSection.addData("Auto Compaction", toString(diskStoreDetails.isAutoCompact(), "Yes", "No"));
diskStoreSection.addData("Compaction Threshold", diskStoreDetails.getCompactionThreshold());
diskStoreSection.addData("Max Oplog Size", diskStoreDetails.getMaxOplogSize());
diskStoreSection.addData("Queue Size", diskStoreDetails.getQueueSize());
diskStoreSection.addData("Time Interval", diskStoreDetails.getTimeInterval());
diskStoreSection.addData("Write Buffer Size", diskStoreDetails.getWriteBufferSize());
diskStoreSection.addData("PDX Serialization Meta-Data Stored",
toString(diskStoreDetails.isPdxSerializationMetaDataStored(), "Yes", "No"));
final TabularResultData diskDirTable = diskStoreData.addSection().addTable();
for (DiskStoreDetails.DiskDirDetails diskDirDetails : diskStoreDetails) {
diskDirTable.accumulate("Disk Directory", diskDirDetails.getAbsolutePath());
diskDirTable.accumulate("Size", diskDirDetails.getSize());
}
final TabularResultData regionTable = diskStoreData.addSection().addTable();
for (DiskStoreDetails.RegionDetails regionDetails : diskStoreDetails.iterateRegions()) {
regionTable.accumulate("Region Path", regionDetails.getFullPath());
regionTable.accumulate("Region Name", regionDetails.getName());
regionTable.accumulate("Persistent", toString(regionDetails.isPersistent(), "Yes", "No"));
regionTable.accumulate("Overflow To Disk", toString(regionDetails.isOverflowToDisk(), "Yes", "No"));
}
final TabularResultData cacheServerTable = diskStoreData.addSection().addTable();
for (DiskStoreDetails.CacheServerDetails cacheServerDetails : diskStoreDetails.iterateCacheServers()) {
cacheServerTable.accumulate("Bind Address", cacheServerDetails.getBindAddress());
cacheServerTable.accumulate("Hostname for Clients", cacheServerDetails.getHostName());
cacheServerTable.accumulate("Port", cacheServerDetails.getPort());
}
final TabularResultData gatewayTable = diskStoreData.addSection().addTable();
for (DiskStoreDetails.GatewayDetails gatewayDetails : diskStoreDetails.iterateGateways()) {
gatewayTable.accumulate("Gateway ID", gatewayDetails.getId());
gatewayTable.accumulate("Persistent", toString(gatewayDetails.isPersistent(), "Yes", "No"));
}
final TabularResultData asyncEventQueueTable = diskStoreData.addSection().addTable();
for (DiskStoreDetails.AsyncEventQueueDetails asyncEventQueueDetails : diskStoreDetails.iterateAsyncEventQueues()) {
asyncEventQueueTable.accumulate("Async Event Queue ID", asyncEventQueueDetails.getId());
}
return ResultBuilder.buildResult(diskStoreData);
}
@CliCommand(value = CliStrings.REVOKE_MISSING_DISK_STORE, help = CliStrings.REVOKE_MISSING_DISK_STORE__HELP)
@CliMetaData(relatedTopic = { CliStrings.TOPIC_GEMFIRE_DISKSTORE })
public Result revokeMissingDiskStore(
@CliOption(key = CliStrings.REVOKE_MISSING_DISK_STORE__ID, mandatory = true, help = CliStrings.REVOKE_MISSING_DISK_STORE__ID__HELP)
String id) {
try {
DistributedSystemMXBean dsMXBean = ManagementService.getManagementService(CacheFactory.getAnyInstance())
.getDistributedSystemMXBean();
if (dsMXBean.revokeMissingDiskStores(id)) {
return ResultBuilder.createInfoResult("Missing disk store successfully revoked");
}
return ResultBuilder.createUserErrorResult("Unable to find missing disk store to revoke");
} catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
} catch (Throwable th) {
SystemFailure.checkFailure();
if (th.getMessage() == null) {
return ResultBuilder.createGemFireErrorResult("An error occurred while revoking missing disk stores: " + th);
}
return ResultBuilder.createGemFireErrorResult("An error occurred while revoking missing disk stores: " + th.getMessage());
}
}
@CliCommand(value = CliStrings.SHOW_MISSING_DISK_STORE, help = CliStrings.SHOW_MISSING_DISK_STORE__HELP)
@CliMetaData(relatedTopic = { CliStrings.TOPIC_GEMFIRE_DISKSTORE })
public Result showMissingDiskStore() {
try {
TabularResultData tabularData = ResultBuilder.createTabularResultData();
boolean accumulatedData = false;
DistributedSystemMXBean dsMXBean = ManagementService.getManagementService(CacheFactory.getAnyInstance())
.getDistributedSystemMXBean();
PersistentMemberDetails[] allPersistentMemberDetails = dsMXBean.listMissingDiskStores();
if (allPersistentMemberDetails != null) {
for (PersistentMemberDetails peristentMemberDetails : allPersistentMemberDetails) {
tabularData.accumulate("Disk Store ID", peristentMemberDetails.getDiskStoreId());
tabularData.accumulate("Host", peristentMemberDetails.getHost());
tabularData.accumulate("Directory", peristentMemberDetails.getDirectory());
accumulatedData = true;
}
}
if (!accumulatedData) {
return ResultBuilder.createInfoResult("No missing disk store found");
}
return ResultBuilder.buildResult(tabularData);
} catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
} catch (Throwable th) {
SystemFailure.checkFailure();
if (th.getMessage() == null) {
return ResultBuilder.createGemFireErrorResult("An error occurred while showing missing disk stores: " + th);
}
return ResultBuilder.createGemFireErrorResult("An error occurred while showing missing disk stores: " + th.getMessage());
}
}
@CliCommand(value=CliStrings.DESCRIBE_OFFLINE_DISK_STORE, help=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__HELP)
@CliMetaData(shellOnly=true, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result describeOfflineDiskStore(
@CliOption (key=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__DISKSTORENAME,
mandatory=true,
help=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__DISKSTORENAME__HELP)
String diskStoreName,
@CliOption (key=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__DISKDIRS,
mandatory=true,
help=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__DISKDIRS__HELP)
@CliMetaData (valueSeparator = ",")
String[] diskDirs,
@CliOption (key=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__REGIONNAME,
help=CliStrings.DESCRIBE_OFFLINE_DISK_STORE__REGIONNAME__HELP,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE)
String regionName) {
try {
final File[] dirs = new File[diskDirs.length];
for (int i = 0; i < diskDirs.length; i++) {
dirs[i] = new File((diskDirs[i]));
}
if (Region.SEPARATOR.equals(regionName)) {
return ResultBuilder.createUserErrorResult(CliStrings.INVALID_REGION_NAME);
}
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PrintStream printStream = new PrintStream(outputStream);
DiskStoreImpl.dumpInfo(printStream, diskStoreName, dirs, regionName);
return ResultBuilder.createInfoResult(outputStream.toString());
} catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
} catch (Throwable th) {
SystemFailure.checkFailure();
if (th.getMessage() == null) {
return ResultBuilder.createGemFireErrorResult("An error occurred while describing offline disk stores: " + th);
}
return ResultBuilder.createGemFireErrorResult("An error occurred while describing offline disk stores: " + th.getMessage());
}
}
@CliCommand(value=CliStrings.VALIDATE_DISK_STORE, help=CliStrings.VALIDATE_DISK_STORE__HELP)
@CliMetaData(shellOnly=true, relatedTopic = {CliStrings.TOPIC_GEMFIRE_DISKSTORE}) //offline command
public Result validateDiskStore(
@CliOption(key=CliStrings.VALIDATE_DISK_STORE__NAME, mandatory=true,
help=CliStrings.VALIDATE_DISK_STORE__NAME__HELP)
String diskStoreName,
@CliOption(key=CliStrings.VALIDATE_DISK_STORE__DISKDIRS,
mandatory=true,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.VALIDATE_DISK_STORE__DISKDIRS__HELP)
@CliMetaData (valueSeparator = ",")
String[] diskDirs) {
try {
String resultString = new String();
// create a new process ...bug 46075
StringBuilder dirList = new StringBuilder();
for (int i = 0; i < diskDirs.length; i++) {
dirList.append(diskDirs[i]);
dirList.append(";");
}
List commandList = new ArrayList();
commandList.add(System.getProperty("java.home") + File.separatorChar
+ "bin" + File.separatorChar + "java");
commandList.add("-classpath");
commandList.add(System.getProperty("java.class.path", "."));
commandList.add(DiskStoreValidater.class.getName());
commandList.add(diskStoreName);
commandList.add(dirList.toString());
ProcessBuilder procBuilder = new ProcessBuilder(commandList);
StringBuilder output = new StringBuilder();
String errorString = new String();
Process validateDiskStoreProcess = procBuilder.redirectErrorStream(true).start();
InputStream inputStream = validateDiskStoreProcess.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String line = null;
while ((line = br.readLine()) != null) {
output.append(line).append(GfshParser.LINE_SEPARATOR);
}
validateDiskStoreProcess.destroy();
if (errorString != null) {
output.append(errorString).append(GfshParser.LINE_SEPARATOR);
}
resultString = "Validating " + diskStoreName + GfshParser.LINE_SEPARATOR + output.toString();
return ResultBuilder.createInfoResult(resultString.toString());
} catch (IOException ex) {
return ResultBuilder
.createGemFireErrorResult(CliStrings.format(CliStrings.VALIDATE_DISK_STORE__MSG__IO_ERROR,diskStoreName, ex.getMessage() ));
} catch (Exception ex) {
return ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.VALIDATE_DISK_STORE__MSG__ERROR,diskStoreName, ex.getMessage()));
}
}
@CliCommand(value=CliStrings.ALTER_DISK_STORE, help=CliStrings.ALTER_DISK_STORE__HELP)
@CliMetaData(shellOnly=true, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result alterOfflineDiskStore(
@CliOption (key=CliStrings.ALTER_DISK_STORE__DISKSTORENAME,
mandatory=true,
help=CliStrings.ALTER_DISK_STORE__DISKSTORENAME__HELP)
String diskStoreName,
@CliOption (key=CliStrings.ALTER_DISK_STORE__REGIONNAME,
mandatory=true,
help=CliStrings.ALTER_DISK_STORE__REGIONNAME__HELP)
String regionName,
@CliOption (key=CliStrings.ALTER_DISK_STORE__DISKDIRS,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.ALTER_DISK_STORE__DISKDIRS__HELP,
mandatory=true)
@CliMetaData (valueSeparator = ",")
String[] diskDirs,
@CliOption (key=CliStrings.ALTER_DISK_STORE__LRU__EVICTION__ALGORITHM,
help=CliStrings.ALTER_DISK_STORE__LRU__EVICTION__ALGORITHM__HELP)
String lruEvictionAlgo,
@CliOption (key=CliStrings.ALTER_DISK_STORE__LRU__EVICTION__ACTION,
help=CliStrings.ALTER_DISK_STORE__LRU__EVICTION__ACTION__HELP)
String lruEvictionAction,
@CliOption (key=CliStrings.ALTER_DISK_STORE__LRU__EVICTION__LIMIT,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.ALTER_DISK_STORE__LRU__EVICTION__LIMIT__HELP)
Integer lruEvictionLimit,
@CliOption (key=CliStrings.ALTER_DISK_STORE__CONCURRENCY__LEVEL,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.ALTER_DISK_STORE__CONCURRENCY__LEVEL__HELP)
Integer concurrencyLevel,
@CliOption (key=CliStrings.ALTER_DISK_STORE__INITIAL__CAPACITY,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.ALTER_DISK_STORE__INITIAL__CAPACITY__HELP)
Integer initialCapacity,
@CliOption (key=CliStrings.ALTER_DISK_STORE__LOAD__FACTOR,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.ALTER_DISK_STORE__LOAD__FACTOR__HELP)
Float loadFactor,
@CliOption (key=CliStrings.ALTER_DISK_STORE__COMPRESSOR,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
specifiedDefaultValue="none",
help=CliStrings.ALTER_DISK_STORE__COMPRESSOR__HELP)
String compressorClassName,
@CliOption (key=CliStrings.ALTER_DISK_STORE__STATISTICS__ENABLED,
unspecifiedDefaultValue=CliMetaData.ANNOTATION_NULL_VALUE,
help=CliStrings.ALTER_DISK_STORE__STATISTICS__ENABLED__HELP)
Boolean statisticsEnabled,
@CliOption (key=CliStrings.ALTER_DISK_STORE__REMOVE,
help=CliStrings.ALTER_DISK_STORE__REMOVE__HELP,
mandatory = false,
specifiedDefaultValue = "true",
unspecifiedDefaultValue = "false")
boolean remove) {
Result result = null;
try {
File[] dirs = null;
if (diskDirs != null) {
dirs = new File[diskDirs.length];
for (int i=0; i < diskDirs.length; i++) {
dirs[i] = new File((diskDirs[i]));
}
}
if (regionName.equals(Region.SEPARATOR)) {
return ResultBuilder.createUserErrorResult(CliStrings.INVALID_REGION_NAME);
}
if ((lruEvictionAlgo != null) ||
(lruEvictionAction != null) ||
(lruEvictionLimit != null) ||
(concurrencyLevel != null) ||
(initialCapacity != null) ||
(loadFactor != null) ||
(compressorClassName != null) ||
(statisticsEnabled != null)
) {
if (!remove) {
String lruEvictionLimitString = lruEvictionLimit == null ? null : lruEvictionLimit.toString();
String concurrencyLevelString = concurrencyLevel == null ? null : concurrencyLevel.toString();
String initialCapacityString = initialCapacity == null ? null : initialCapacity.toString();
String loadFactorString = loadFactor == null ? null : loadFactor.toString();
String statisticsEnabledString = statisticsEnabled == null ? null : statisticsEnabled.toString();
if ("none".equals(compressorClassName)) {
compressorClassName = "";
}
String resultMessage = DiskStoreImpl.modifyRegion(diskStoreName, dirs, "/"+regionName,
lruEvictionAlgo, lruEvictionAction, lruEvictionLimitString,
concurrencyLevelString, initialCapacityString, loadFactorString,
compressorClassName, statisticsEnabledString, false);
result = ResultBuilder.createInfoResult(resultMessage);
} else {
result = ResultBuilder.createParsingErrorResult("Cannot use the --remove=true parameter with any other parameters");
}
} else {
if (remove) {
DiskStoreImpl.destroyRegion(diskStoreName, dirs, "/" + regionName);
result = ResultBuilder.createInfoResult("The region " + regionName + " was successfully removed from the disk store " + diskStoreName);
} else {
//Please provide an option
result = ResultBuilder.createParsingErrorResult("Please provide a relevant parameter");
}
}
//Catch the IllegalArgumentException thrown by the modifyDiskStore function and sent the
} catch (IllegalArgumentException e) {
String message = "Please check the parameters";
message += "\n" + e.getMessage();
result = ResultBuilder.createGemFireErrorResult(message);
} catch (IllegalStateException e) {
result = ResultBuilder.createGemFireErrorResult(e.getMessage());
} catch (CacheExistsException e) {
//Indicates that the command is being used when a cache is open
result = ResultBuilder.createGemFireErrorResult("Cannot execute " + CliStrings.ALTER_DISK_STORE + " when a cache exists (Offline command)");
} catch (Exception e) {
result = createErrorResult(e.getMessage());
}
return result;
}
@CliCommand(value=CliStrings.DESTROY_DISK_STORE, help=CliStrings.DESTROY_DISK_STORE__HELP)
@CliMetaData(shellOnly=false, relatedTopic={CliStrings.TOPIC_GEMFIRE_DISKSTORE})
public Result destroyDiskStore(
@CliOption (key=CliStrings.DESTROY_DISK_STORE__NAME,
mandatory=true,
help=CliStrings.DESTROY_DISK_STORE__NAME__HELP)
String name,
@CliOption(key=CliStrings.DESTROY_DISK_STORE__GROUP,
help=CliStrings.DESTROY_DISK_STORE__GROUP__HELP,
optionContext=ConverterHint.MEMBERGROUP)
@CliMetaData (valueSeparator = ",")
String group) {
try {
TabularResultData tabularData = ResultBuilder.createTabularResultData();
boolean accumulatedData = false;
Set targetMembers;
try {
targetMembers = CliUtil.findAllMatchingMembers(group, null);
} catch (CommandResultException crex) {
return crex.getResult();
}
ResultCollector rc = CliUtil.executeFunction(new DestroyDiskStoreFunction(), new Object[] { name },
targetMembers);
List results = CliFunctionResult.cleanResults((List) rc.getResult());
for (CliFunctionResult result : results) {
if (result.getThrowable() != null) {
tabularData.accumulate("Member", result.getMemberIdOrName());
tabularData.accumulate("Result", "ERROR: " + result.getThrowable().getClass().getName() + ": "
+ result.getThrowable().getMessage());
accumulatedData = true;
tabularData.setStatus(Status.ERROR);
} else if (result.getMessage() != null) {
tabularData.accumulate("Member", result.getMemberIdOrName());
tabularData.accumulate("Result", result.getMessage());
accumulatedData = true;
}
}
if (!accumulatedData) {
return ResultBuilder.createInfoResult("No matching disk stores found.");
}
return ResultBuilder.buildResult(tabularData);
} catch (VirtualMachineError e) {
SystemFailure.initiateFailure(e);
throw e;
} catch (Throwable th) {
SystemFailure.checkFailure();
return ResultBuilder.createGemFireErrorResult(CliStrings.format(CliStrings.DESTROY_DISK_STORE__ERROR_WHILE_DESTROYING_REASON_0,
new Object[] { th.getMessage() }));
}
}
private Result createErrorResult(String message) {
ErrorResultData erd = ResultBuilder.createErrorResultData();
erd.addLine(message);
return ResultBuilder.buildResult(erd);
}
@CliAvailabilityIndicator({CliStrings.BACKUP_DISK_STORE, CliStrings.COMPACT_DISK_STORE,
CliStrings.DESCRIBE_DISK_STORE, CliStrings.LIST_DISK_STORE, CliStrings.REVOKE_MISSING_DISK_STORE,
CliStrings.SHOW_MISSING_DISK_STORE, CliStrings.CREATE_DISK_STORE, CliStrings.DESTROY_DISK_STORE})
public boolean diskStoreCommandsAvailable() {
// these disk store commands are always available in GemFire
return (!CliUtil.isGfshVM() || (getGfsh() != null && getGfsh().isConnectedAndReady()));
}
@CliAvailabilityIndicator({CliStrings.DESCRIBE_OFFLINE_DISK_STORE})
public boolean offlineDiskStoreCommandsAvailable() {
return true;
}
}