1 /*
   2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
   3  * 
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * The contents of this file are subject to the terms of either the Universal Permissive License
   7  * v 1.0 as shown at http://oss.oracle.com/licenses/upl
   8  *
   9  * or the following license:
  10  *
  11  * Redistribution and use in source and binary forms, with or without modification, are permitted
  12  * provided that the following conditions are met:
  13  * 
  14  * 1. Redistributions of source code must retain the above copyright notice, this list of conditions
  15  * and the following disclaimer.
  16  * 
  17  * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
  18  * conditions and the following disclaimer in the documentation and/or other materials provided with
  19  * the distribution.
  20  * 
  21  * 3. Neither the name of the copyright holder nor the names of its contributors may be used to
  22  * endorse or promote products derived from this software without specific prior written permission.
  23  * 
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
  25  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  26  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  27  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  30  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
  31  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33 package org.openjdk.jmc.rjmx.services.internal;
  34 
  35 import java.io.IOException;
  36 import java.util.ArrayList;
  37 import java.util.Collection;
  38 import java.util.Collections;
  39 import java.util.HashMap;
  40 import java.util.List;
  41 import java.util.Map;
  42 import java.util.concurrent.Callable;
  43 
  44 import javax.management.Descriptor;
  45 import javax.management.InstanceNotFoundException;
  46 import javax.management.MBeanException;
  47 import javax.management.MBeanInfo;
  48 import javax.management.MBeanOperationInfo;
  49 import javax.management.MBeanServerConnection;
  50 import javax.management.ObjectName;
  51 import javax.management.ReflectionException;
  52 
  53 import org.openjdk.jmc.rjmx.ConnectionToolkit;
  54 import org.openjdk.jmc.rjmx.RJMXPlugin;
  55 import org.openjdk.jmc.rjmx.ServiceNotAvailableException;
  56 import org.openjdk.jmc.rjmx.services.IDiagnosticCommandService;
  57 import org.openjdk.jmc.rjmx.services.IOperation.OperationImpact;
  58 import org.openjdk.jmc.rjmx.services.IllegalOperandException;
  59 import org.openjdk.jmc.rjmx.util.internal.SimpleAttributeInfo;
  60 
  61 public class HotSpot24DiagnosticCommandService implements IDiagnosticCommandService {
  62 
  63         private static final ObjectName DIAGNOSTIC_BEAN = ConnectionToolkit
  64                         .createObjectName("com.sun.management:type=DiagnosticCommand"); //$NON-NLS-1$
  65         private static final String OPERATION_UPDATE = "update"; //$NON-NLS-1$
  66         private final MBeanServerConnection m_mbeanServer;
  67         private final Map<String, String> commandNameToOperation = new HashMap<>();
  68         private Collection<DiagnosticCommand> operations;
  69 
  70         private static final String IMPACT = "dcmd.vmImpact"; //$NON-NLS-1$
  71         private static final String NAME = "dcmd.name"; //$NON-NLS-1$
  72         private static final String DESCRIPTION = "dcmd.description"; //$NON-NLS-1$
  73 //      private final static String HELP = "dcmd.help"; //$NON-NLS-1$
  74         private static final String ARGUMENTS = "dcmd.arguments"; //$NON-NLS-1$
  75         private static final String ARGUMENT_NAME = "dcmd.arg.name"; //$NON-NLS-1$
  76         private static final String ARGUMENT_DESCRIPTION = "dcmd.arg.description"; //$NON-NLS-1$
  77         private static final String ARGUMENT_MANDATORY = "dcmd.arg.isMandatory"; //$NON-NLS-1$
  78         private static final String ARGUMENT_TYPE = "dcmd.arg.type"; //$NON-NLS-1$
  79         private static final String ARGUMENT_OPTION = "dcmd.arg.isOption"; //$NON-NLS-1$
  80         private static final String ARGUMENT_MULITPLE = "dcmd.arg.isMultiple"; //$NON-NLS-1$
  81 
  82         private static List<DiagnosticCommandParameter> extractSignature(Descriptor args) {
  83                 if (args != null) {
  84                         String[] argNames = args.getFieldNames();
  85                         List<DiagnosticCommandParameter> parameters = new ArrayList<>(argNames.length);
  86                         for (String argName : argNames) {
  87                                 Descriptor arg = (Descriptor) args.getFieldValue(argName);
  88                                 parameters.add(new DiagnosticCommandParameter(arg));
  89                         }
  90                         return parameters;
  91                 } else {
  92                         return Collections.emptyList();
  93                 }
  94         }
  95 
  96         private static OperationImpact extractImpact(Descriptor d) {
  97                 String impact = d.getFieldValue(IMPACT).toString();
  98                 if (impact.startsWith("Low")) { //$NON-NLS-1$
  99                         return OperationImpact.IMPACT_LOW;
 100                 }
 101                 if (impact.startsWith("Medium")) { //$NON-NLS-1$
 102                         return OperationImpact.IMPACT_MEDIUM;
 103                 }
 104                 if (impact.startsWith("High")) { //$NON-NLS-1$
 105                         return OperationImpact.IMPACT_HIGH;
 106                 }
 107                 return OperationImpact.IMPACT_UNKNOWN;
 108         }
 109 
 110         private static String extractType(Descriptor d) {
 111                 boolean isMultiple = Boolean.parseBoolean(d.getFieldValue(ARGUMENT_MULITPLE).toString());
 112                 String typeName = d.getFieldValue(ARGUMENT_TYPE).toString();
 113                 if (isMultiple) {
 114                         if (typeName.equals("STRING SET")) { //$NON-NLS-1$
 115                                 return String[].class.getName();
 116                         } else {
 117                                 return typeName.toLowerCase().replace(' ', '_') + '*';
 118                         }
 119                 }
 120                 if (typeName.equals("BOOLEAN")) { //$NON-NLS-1$
 121                         return Boolean.class.getName();
 122                 } else if (typeName.equals("STRING") || typeName.equals("NANOTIME") || typeName.equals("MEMORY SIZE")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 123                         return String.class.getName();
 124                 } else if (typeName.equals("JLONG")) { //$NON-NLS-1$
 125                         return Long.class.getName();
 126                 } else {
 127                         return typeName.toLowerCase().replace(' ', '_');
 128                 }
 129         }
 130 
 131         private static String extractDescription(Descriptor d) {
 132                 // FIXME: Argument descriptions for JFR operations contains \" that should be ". Workaround for now.
 133                 String desc = d.getFieldValue(ARGUMENT_DESCRIPTION).toString().trim().replaceAll("\\\\\"", "\""); //$NON-NLS-1$ //$NON-NLS-2$
 134                 return desc.length() > 0 ? desc : d.getFieldValue(ARGUMENT_NAME).toString().trim();
 135         }
 136 
 137         private static class ArgumentBuilder {
 138                 private final List<String> arguments = new ArrayList<>();
 139 
 140                 public void appendArgument(Object value, DiagnosticCommandParameter parameterInfo)
 141                                 throws IllegalOperandException {
 142                         if (parameterInfo.isMultiple) {
 143                                 if (value.getClass().isArray()) {
 144                                         for (Object o : ((Object[]) value)) {
 145                                                 appendValue(o, parameterInfo);
 146                                         }
 147                                 } else {
 148                                         throw new IllegalOperandException(parameterInfo);
 149                                 }
 150                         } else {
 151                                 appendValue(value, parameterInfo);
 152                         }
 153                 }
 154 
 155                 private void appendValue(Object value, DiagnosticCommandParameter parameterInfo)
 156                                 throws IllegalOperandException {
 157                         StringBuilder sb = new StringBuilder();
 158                         if (parameterInfo.isOption) {
 159                                 sb.append(parameterInfo.parameterName).append('=');
 160                         }
 161                         String stringValue = String.valueOf(value);
 162                         if (stringValue.indexOf('"') >= 0) {
 163                                 throw new IllegalOperandException(parameterInfo);
 164                         } else if (stringValue.indexOf(' ') >= 0) {
 165                                 sb.append('"').append(stringValue).append('"');
 166                         } else {
 167                                 sb.append(stringValue);
 168                         }
 169                         arguments.add(sb.toString());
 170                 }
 171 
 172                 public String[] asArray() {
 173                         return arguments.toArray(new String[arguments.size()]);
 174                 }
 175         }
 176 
 177         private static class DiagnosticCommandParameter extends SimpleAttributeInfo {
 178                 private final boolean isOption;
 179                 private final boolean isMultiple;
 180                 private final boolean isRequired;
 181                 private final String parameterName;
 182 
 183                 public DiagnosticCommandParameter(Descriptor d) {
 184                         super(d.getFieldValue(ARGUMENT_NAME).toString(), extractType(d), extractDescription(d));
 185                         parameterName = d.getFieldValue(ARGUMENT_NAME).toString();
 186                         isOption = Boolean.parseBoolean(d.getFieldValue(ARGUMENT_OPTION).toString());
 187                         isMultiple = Boolean.parseBoolean(d.getFieldValue(ARGUMENT_MULITPLE).toString());
 188                         isRequired = Boolean.parseBoolean(d.getFieldValue(ARGUMENT_MANDATORY).toString());
 189                         RJMXPlugin.getDefault().getLogger()
 190                                         .finest("DiagnosticCommandArg created: " + getType() + ' ' + getName() + ' ' + getDescription() //$NON-NLS-1$
 191                                                         + (isRequired ? " isRequired" : "") //$NON-NLS-1$ //$NON-NLS-2$
 192                                                         + (isOption ? " isOption" : "") + (isMultiple ? " isMultiple" : "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
 193                 }
 194 
 195         }
 196 
 197         private class DiagnosticCommand extends AbstractOperation<DiagnosticCommandParameter> {
 198 
 199                 public DiagnosticCommand(Descriptor d, String returnType) {
 200                         super(d.getFieldValue(NAME).toString(), d.getFieldValue(DESCRIPTION).toString(), returnType,
 201                                         extractSignature((Descriptor) d.getFieldValue(ARGUMENTS)), extractImpact(d));
 202                         RJMXPlugin.getDefault().getLogger()
 203                                         .finest("DiagnosticCommand created: " + getName() + ' ' + getReturnType() + ' ' + getImpact()); //$NON-NLS-1$
 204                 }
 205 
 206                 @Override
 207                 public Callable<?> getInvocator(Object ... argValues) throws IllegalOperandException {
 208                         ArgumentBuilder ab = new ArgumentBuilder();
 209                         List<DiagnosticCommandParameter> args = getSignature();
 210                         for (int i = 0; i < args.size(); i++) {
 211                                 if (i >= argValues.length || argValues[i] == null) {
 212                                         if (args.get(i).isRequired) {
 213                                                 // Argument value is required but not provided
 214                                                 IllegalOperandException ex = new IllegalOperandException(args.get(i));
 215                                                 while (++i < args.size()) {
 216                                                         // Check for other attributes with the same error
 217                                                         if (args.get(i).isRequired) {
 218                                                                 ex.addInvalidValue(args.get(i));
 219                                                         }
 220                                                 }
 221                                                 throw ex;
 222                                         } else {
 223                                                 continue;
 224                                         }
 225                                 }
 226                                 ab.appendArgument(argValues[i], args.get(i));
 227                         }
 228                         final String[] arguments = ab.asArray();
 229                         return new Callable<Object>() {
 230 
 231                                 @Override
 232                                 public Object call() throws Exception {
 233                                         return execute(arguments);
 234                                 }
 235 
 236                                 @Override
 237                                 public String toString() {
 238                                         return getName() + ' ' + asString(arguments);
 239                                 }
 240                         };
 241                 }
 242 
 243                 private String asString(String[] array) {
 244                         StringBuilder sb = new StringBuilder();
 245                         if (array != null) {
 246                                 for (int i = 0; i < array.length; i += 1) {
 247                                         sb.append(array[i]);
 248                                         if (i + 1 < array.length) {
 249                                                 sb.append(' ');
 250                                         }
 251                                 }
 252                         }
 253                         return sb.toString();
 254                 }
 255 
 256                 private String execute(String[] arguments)
 257                                 throws InstanceNotFoundException, MBeanException, ReflectionException, IOException {
 258                         String operation = commandNameToOperation.get(getName());
 259                         RJMXPlugin.getDefault().getLogger()
 260                                         .fine("Running " + getName() + " |" + operation + '|' + asString(arguments) + '|'); //$NON-NLS-1$ //$NON-NLS-2$
 261                         if (operation == null) {
 262                                 throw new RuntimeException("Unavailable diagnostic command " + getName() + '!'); //$NON-NLS-1$
 263                         }
 264                         if (getSignature().size() > 0) {
 265                                 return (String) m_mbeanServer.invoke(DIAGNOSTIC_BEAN, operation, new Object[] {arguments},
 266                                                 new String[] {String[].class.getName()});
 267                         } else {
 268                                 return (String) m_mbeanServer.invoke(DIAGNOSTIC_BEAN, operation, new Object[0], new String[0]);
 269                         }
 270                 }
 271 
 272         }
 273 
 274         public HotSpot24DiagnosticCommandService(MBeanServerConnection server) throws ServiceNotAvailableException {
 275                 m_mbeanServer = server;
 276                 try {
 277                         refreshOperations();
 278                 } catch (Exception e) {
 279                         throw new ServiceNotAvailableException("Unable to retrieve diagnostic commands!"); //$NON-NLS-1$
 280                 }
 281         }
 282 
 283         @Override
 284         public synchronized Collection<DiagnosticCommand> getOperations() throws Exception {
 285                 refreshOperations();
 286                 return operations;
 287         }
 288 
 289         private void refreshOperations() throws Exception {
 290                 RJMXPlugin.getDefault().getLogger().finer("Refreshing diagnostic operations");
 291                 MBeanInfo info = m_mbeanServer.getMBeanInfo(DIAGNOSTIC_BEAN);
 292                 operations = new ArrayList<>(info.getOperations().length);
 293                 commandNameToOperation.clear();
 294                 for (MBeanOperationInfo oper : info.getOperations()) {
 295                         if (!oper.getName().equals(OPERATION_UPDATE)) {
 296                                 Descriptor descriptor = oper.getDescriptor();
 297                                 DiagnosticCommand c = new DiagnosticCommand(descriptor, oper.getReturnType());
 298                                 operations.add(c);
 299                                 commandNameToOperation.put(c.getName(), oper.getName());
 300                         }
 301                 }
 302         }
 303 
 304         @Override
 305         public String runCtrlBreakHandlerWithResult(String command) throws Exception {
 306                 int index = command.indexOf(' ');
 307                 if (index > 0) {
 308                         String operationName = command.substring(0, index);
 309                         return findDiagnosticCommand(operationName).execute(splitArguments(command.substring(index + 1).trim()));
 310                 } else {
 311                         return findDiagnosticCommand(command).execute(null);
 312                 }
 313         }
 314 
 315         private String[] splitArguments(String commandArguments) {
 316                 List<String> arguments = new ArrayList<>();
 317                 StringBuilder argument = new StringBuilder();
 318                 boolean inCitation = false;
 319                 for (char c : commandArguments.toCharArray()) {
 320                         if (inCitation) {
 321                                 if (c == '"') {
 322                                         inCitation = false;
 323                                 }
 324                                 argument.append(c);
 325                         } else {
 326                                 if (Character.isWhitespace(c)) {
 327                                         if (argument.length() > 0) {
 328                                                 arguments.add(argument.toString());
 329                                                 argument = new StringBuilder();
 330                                         }
 331                                 } else {
 332                                         if (c == '"') {
 333                                                 inCitation = true;
 334                                         }
 335                                         argument.append(c);
 336                                 }
 337                         }
 338                 }
 339                 if (argument.length() > 0) {
 340                         arguments.add(argument.toString());
 341                 }
 342                 return arguments.toArray(new String[arguments.size()]);
 343         }
 344 
 345         private synchronized DiagnosticCommand findDiagnosticCommand(String operationName) throws Exception {
 346                 for (DiagnosticCommand op : operations) {
 347                         if (op.getName().equals(operationName)) {
 348                                 return op;
 349                         }
 350                 }
 351                 throw new IllegalArgumentException("Unavailable diagnostic command " + operationName + '!'); //$NON-NLS-1$
 352         }
 353 
 354 }