@Override
  public void run(String... args) throws Exception {
    // TODO Auto-generated method stub
    final AttachProvider attachProvider = AttachProvider.providers().get(0);

    VirtualMachineDescriptor descriptor = null;
    for (VirtualMachineDescriptor virtualMachineDescriptor : attachProvider.listVirtualMachines()) {

      if (virtualMachineDescriptor.displayName().equals(applicationName)) {
        descriptor = virtualMachineDescriptor;
      }
    }
    final VirtualMachine virtualMachine = attachProvider.attachVirtualMachine(descriptor);
    virtualMachine.loadAgent(managmentAgentJar, "com.sun.management.jmxremote");
    final Object portObject =
        virtualMachine
            .getAgentProperties()
            .get("com.sun.management.jmxremote.localConnectorAddress");

    final JMXServiceURL target = new JMXServiceURL(portObject + "");
    final JMXConnector connector = JMXConnectorFactory.connect(target);
    final MBeanServerConnection remote = connector.getMBeanServerConnection();

    final ObjectName objectName =
        new ObjectName("Catalina:type=Manager,host=localhost,context=" + context);
    System.out.println("Start");

    System.out.println("ActiveSession = " + remote.getAttribute(objectName, "activeSessions"));
    System.out.println("End");
  }
  private void attachAgent()
      throws IOException, AttachNotSupportedException, AgentLoadException,
          AgentInitializationException {

    String name = ManagementFactory.getRuntimeMXBean().getName();
    String pid = name.substring(0, name.indexOf("@"));
    System.out.println(name);

    final VirtualMachine m = VirtualMachine.attach(pid);

    m.loadAgent("target/notsoserial-1.0-SNAPSHOT.jar");
  }
Exemple #3
0
  /**
   * @param args
   * @throws Exception
   */
  public static void main(final String[] args) throws Exception {
    if (args == null || args.length < 1) {
      throw new IllegalStateException("args");
    }

    final String pid = args[0];

    final File thisJar = getJarFile();

    final VirtualMachine vm = VirtualMachine.attach(pid);
    vm.loadAgent(thisJar.getAbsolutePath(), "");
    vm.detach();
  }
Exemple #4
0
  /**
   * Tests this VirtualMachine for equality with another object.
   *
   * <p>
   *
   * <p>If the given object is not a VirtualMachine then this method returns <tt>false</tt>. For two
   * VirtualMachines to be considered equal requires that they both reference the same provider, and
   * their {@link VirtualMachineDescriptor#id() identifiers} are equal.
   *
   * <p>
   *
   * <p>This method satisfies the general contract of the {@link java.lang.Object#equals(Object)
   * Object.equals} method.
   *
   * @param ob The object to which this object is to be compared
   * @return <tt>true</tt> if, and only if, the given object is a VirtualMachine that is equal to
   *     this VirtualMachine.
   */
  public boolean equals(Object ob) {
    if (ob == this) {
      return true;
    }

    if (!(ob instanceof VirtualMachine)) {
      return false;
    }

    VirtualMachine other = (VirtualMachine) ob;

    return other.provider() == provider() && other.id().equals(id());
  }
  @Nonnull
  protected MBeanServerConnection connectToMbeanServer(@Nonnull String pid) throws IOException {
    VirtualMachine vm;
    try {
      Integer.parseInt(pid);
    } catch (Exception e) {
      logger.warn("Exception parsing PID '{}'", pid, e);
    }
    try {
      vm = VirtualMachine.attach(pid);
    } catch (Exception e) {
      throw new IllegalStateException("Exception attaching VM with PID '" + pid + "'", e);
    }

    logger.trace("VM Agent Properties");
    for (String key : new TreeSet<String>(vm.getAgentProperties().stringPropertyNames())) {
      logger.trace("\t {}: {}", key, vm.getAgentProperties().get(key));
    }
    logger.trace("VM System Properties");
    for (String key : new TreeSet<String>(vm.getSystemProperties().stringPropertyNames())) {
      logger.trace("\t {}: {}", key, vm.getSystemProperties().get(key));
    }

    String connectorAddress =
        vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress");
    if (connectorAddress == null) {
      String agent =
          vm.getSystemProperties().getProperty("java.home")
              + File.separator
              + "lib"
              + File.separator
              + "management-agent.jar";
      try {
        vm.loadAgent(agent);
      } catch (Exception e) {
        throw new IllegalStateException("Exception loading agent " + agent);
      }
      connectorAddress =
          vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress");
    }

    if (connectorAddress == null) {
      throw new IllegalStateException(
          "Could not attach to pid: " + pid + ". No connector available");
    }
    logger.trace("Connect to {} ...", connectorAddress);

    JMXConnector connector = JMXConnectorFactory.connect(new JMXServiceURL(connectorAddress));

    return connector.getMBeanServerConnection();
  }
Exemple #6
0
  /*
   * Find the VM instance running Cougar based on COUGARVMNAME1 and COUGARVMNAME2
   * fields, and attach, setting the JmxConnector to be used by other methods.
   *
   */
  private void setJMXConnectionFactory() {

    String id = null;
    List<VirtualMachineDescriptor> vms = VirtualMachine.list();
    Boolean foundVM = false;

    for (VirtualMachineDescriptor vmd : vms) {

      String vmName = cleanCommandLineArgs(vmd.displayName());

      id = vmd.id();
      JMXConnector jmxConnector = null;
      try {
        jmxConnector = createJMXConnector(id);
      } catch (Exception e) { // Do Nothing move onto next vm
        continue;
      }
      try {
        if (!makeServerConnection(jmxConnector)) {
          continue;
        }
      } catch (Exception e) { // Do Nothing move onto next vm
        continue;
      }

      // No exceptions thrown so we have our cougar vm
      jmxc = jmxConnector;
      foundVM = true;
      break;
    }
    if (!foundVM) {
      throw new RuntimeException("Unable to find cougar VM");
    }
  }
  private JMXConnector initJMXConnector(String svcName)
      throws IOException, AttachNotSupportedException, AgentLoadException,
          AgentInitializationException {
    int pid = PlatformUtils.getServicePid(svcName);
    log.info("{} service pid {}", svcName, pid);

    VirtualMachine vm = VirtualMachine.attach(String.valueOf(pid));
    try {
      String connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);
      if (connectorAddress == null) {
        String agent =
            Strings.join(
                File.separator,
                vm.getSystemProperties().getProperty("java.home"),
                "lib",
                "management-agent.jar");
        vm.loadAgent(agent);

        connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);
      }

      JMXServiceURL serviceURL = new JMXServiceURL(connectorAddress);
      return JMXConnectorFactory.connect(serviceURL);
    } finally {
      vm.detach();
    }
  }
    private synchronized void loadManagementAgent() throws IOException {
      VirtualMachine vm = null;
      String name = String.valueOf(vmid);
      try {
        vm = VirtualMachine.attach(name);
      } catch (AttachNotSupportedException x) {
        throw new IOException(x);
      }
      // try to enable local JMX via jcmd command
      if (!loadManagementAgentViaJcmd(vm)) {
        // load the management agent into the target VM
        loadManagementAgentViaJar(vm);
      }

      // get the connector address
      Properties agentProps = vm.getAgentProperties();
      address = (String) agentProps.get(LOCAL_CONNECTOR_ADDRESS_PROP);

      vm.detach();
    }
  private Stream<VirtualMachine> attach(VirtualMachineDescriptor vmDescriptor) {
    try {
      com.sun.tools.attach.VirtualMachine vm =
          com.sun.tools.attach.VirtualMachine.attach(vmDescriptor);
      String vmArgs = vm.getAgentProperties().getProperty(VM_ARGS);

      String id = vmDescriptor.id();
      String displayName = vmDescriptor.displayName();
      boolean agentLoaded = vmArgs.contains(AGENT_NAME);
      String userDir = getUserDir(vm);

      return Stream.of(new VirtualMachine(id, displayName, agentLoaded, userDir));
    } catch (AttachNotSupportedException e) {
      logger.warn(e.getMessage());
    } catch (IOException e) {
      if (!noSuchProcess(e)) {
        logger.warn(e.getMessage(), e);
      }
    }
    return Stream.empty();
  }
Exemple #10
0
  public JMXConnector createJMXConnector(String id)
      throws IOException, AgentLoadException, AgentInitializationException,
          AttachNotSupportedException {

    // attach to the target application
    VirtualMachine vm = VirtualMachine.attach(id);

    // get the connector address
    String connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);

    // no connector address, so we start the JMX agent
    if (connectorAddress == null) {
      String agent =
          vm.getSystemProperties().getProperty("java.home")
              + File.separator
              + "lib"
              + File.separator
              + "management-agent.jar";
      vm.loadAgent(agent);

      // agent is started, get the connector address
      connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);
    }

    // establish connection to connector server
    JMXServiceURL url = new JMXServiceURL(connectorAddress);
    return JMXConnectorFactory.connect(url);
  }
 public void poll() {
   Set<VirtualMachineDescriptor> current =
       new HashSet<>(com.sun.tools.attach.VirtualMachine.list());
   difference(
       current,
       previous,
       machine -> {
         ProfileListener profileListener = listener.onNewMachine(machine);
         if (machine.isAgentLoaded() && profileListener != null) {
           try {
             conductor.pipeFile(machine.getLogFile(), machine, profileListener);
           } catch (IOException e) {
             logger.error(e.getMessage(), e);
           }
         }
       });
   difference(previous, current, listener::onClosedMachine);
   previous = current;
 }
    private void loadManagementAgentViaJar(VirtualMachine vm) throws IOException {
      // Normally in ${java.home}/jre/lib/management-agent.jar but might
      // be in ${java.home}/lib in build environments.

      String agent =
          javaHome
              + File.separator
              + "jre"
              + File.separator
              + // NOI18N
              "lib"
              + File.separator
              + "management-agent.jar"; // NOI18N
      File f = new File(agent);
      if (!f.exists()) {
        agent =
            javaHome
                + File.separator
                + "lib"
                + File.separator
                + // NOI18N
                "management-agent.jar"; // NOI18N
        f = new File(agent);
        if (!f.exists()) {
          throw new IOException("Management agent not found"); // NOI18N
        }
      }

      agent = f.getCanonicalPath();
      try {
        vm.loadAgent(agent, "com.sun.management.jmxremote"); // NOI18N
      } catch (AgentLoadException x) {
        throw new IOException(x);
      } catch (AgentInitializationException x) {
        throw new IOException(x);
      }
    }
  public static void main(String[] args) throws Exception {
    // TODO Auto-generated method stub
    if (args.length != 4) {
      System.err.println("Please provide process id zabbix-host zabbix-port host-guid");
      System.exit(-1);
    }
    String processPid = args[0];
    String zabbixHost = args[1];
    String zabbixPort = args[2];
    String hostGuid = args[3];

    VirtualMachine vm = VirtualMachine.attach(processPid);
    String connectorAddr =
        vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress");
    if (connectorAddr == null) {
      String agent =
          vm.getSystemProperties().getProperty("java.home")
              + File.separator
              + "lib"
              + File.separator
              + "management-agent.jar";
      vm.loadAgent(agent);
      connectorAddr =
          vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress");
    }
    JMXServiceURL serviceURL = new JMXServiceURL(connectorAddr);
    JMXConnector connector = JMXConnectorFactory.connect(serviceURL);
    MBeanServerConnection mbsc = connector.getMBeanServerConnection();
    ObjectName objName = new ObjectName(ManagementFactory.THREAD_MXBEAN_NAME);
    Set<ObjectName> mbeans = mbsc.queryNames(objName, null);
    for (ObjectName name : mbeans) {
      ThreadMXBean threadBean;
      threadBean =
          ManagementFactory.newPlatformMXBeanProxy(mbsc, name.toString(), ThreadMXBean.class);
      long threadIds[] = threadBean.getAllThreadIds();
      for (long threadId : threadIds) {
        ThreadInfo threadInfo = threadBean.getThreadInfo(threadId);
        System.out.println(threadInfo.getThreadName() + " / " + threadInfo.getThreadState());
      }
    }
  }
    private JMXServiceURL getURLForPid(String pid) throws Exception {

      // attach to the target application
      final VirtualMachine vm = VirtualMachine.attach(pid);

      // get the connector address
      String connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);

      // no connector address, so we start the JMX agent
      if (connectorAddress == null) {
        String agent =
            vm.getSystemProperties().getProperty("java.home")
                + File.separator
                + "lib"
                + File.separator
                + "management-agent.jar";
        vm.loadAgent(agent);

        // agent is started, get the connector address
        connectorAddress = vm.getAgentProperties().getProperty(CONNECTOR_ADDRESS);
        assert connectorAddress != null;
      }
      return new JMXServiceURL(connectorAddress);
    }
    private JMXServiceURL parseArgs(String[] args) {

      String host = null;
      int port = 0;
      String pid = null;
      JMXServiceURL serviceURL = null;

      for (int i = 0; i < args.length; i++) {

        if (args[i].startsWith("-url")) {
          // The '-url' option will let you specify a JMXServiceURL
          // on the command line. This is an URL that begins with
          // service:jmx:<protocol>
          //
          if (host != null) throwSyntaxError("-url and -host are mutually exclusive");
          if (pid != null) throwSyntaxError("-pid and -url are mutually exclusive");
          if (port > 0) throwSyntaxError("-port and -url are mutually exclusive");
          if (++i >= args.length) throwSyntaxError("missing JMXServiceURL after -url");

          try {
            serviceURL = new JMXServiceURL(args[i]);
          } catch (Exception x) {
            throwSyntaxError("bad JMXServiceURL after -url: " + x);
          }
          continue;

        } else if (args[i].startsWith("-host")) {
          // The '-host' and '-port' options will let you specify a host
          // and port, and from that will construct the JMXServiceURL of
          // the default RMI connector, that is:
          // service:jmx:rmi:///jndi/rmi://<host>:<port>/jmxrmi"
          //
          if (serviceURL != null) throwSyntaxError("-url and -host are mutually exclusive");
          if (pid != null) throwSyntaxError("-pid and -host are mutually exclusive");
          if (++i >= args.length) throwSyntaxError("missing host after -host");
          try {
            InetAddress.getByName(args[i]);
            host = args[i];
          } catch (Exception x) {
            throwSyntaxError("bad host after -url: " + x);
          }

        } else if (args[i].startsWith("-port")) {
          // The '-host' and '-port' options will let you specify a host
          // and port, and from that will construct the JMXServiceURL of
          // the default RMI connector, that is:
          // service:jmx:rmi:///jndi/rmi://<host>:<port>/jmxrmi"
          //
          if (serviceURL != null) throwSyntaxError("-url and -port are mutually exclusive");
          if (pid != null) throwSyntaxError("-pid and -port are mutually exclusive");
          if (++i >= args.length) throwSyntaxError("missing port number after -port");
          try {
            port = Integer.parseInt(args[i]);
            if (port <= 0) throwSyntaxError("bad port number after -port: " + "must be positive");
          } catch (Exception x) {
            throwSyntaxError("bad port number after -port: " + x);
          }
        } else if (args[i].startsWith("-pid")) {
          // The '-pid' and option will let you specify the PID of the
          // target VM you want to connect to. It will then use the
          // attach API to dynamically launch the JMX agent in the target
          // VM (if needed) and to find out the JMXServiceURL of the
          // the default JMX Connector in that VM.
          //
          if (serviceURL != null) throwSyntaxError("-url and -pid are mutually exclusive");
          if (port > 0) throwSyntaxError("-port and -pid are mutually exclusive");
          if (++i >= args.length) throwSyntaxError("missing pid after -pid");
          try {
            pid = args[i];
          } catch (Exception x) {
            throwSyntaxError("bad pid after -pid: " + x);
          }
        } else if (args[i].startsWith("-help")) {
          final List<String> vmlist = new ArrayList();
          for (VirtualMachineDescriptor vd : VirtualMachine.list()) {
            vmlist.add(vd.id());
          }
          System.err.println(SYNTAX);
          System.err.println("Running JVMs are: " + vmlist);
          throw new IllegalArgumentException(SYNTAX);
        } else {
          throwSyntaxError("Unknown argument: " + args[i]);
        }
      }

      // A JMXServiceURL was given on the command line, just use this.
      //
      if (serviceURL != null) return serviceURL;

      // A -host -port info was given on the command line.
      // Construct the default RMI JMXServiceURL from this.
      //
      if (port > 0) {
        if (host == null) host = "localhost";

        try {
          return new JMXServiceURL(
              "service:jmx:rmi:///jndi/rmi://" + host + ":" + port + "/jmxrmi");
        } catch (Exception x) {
          throwSyntaxError("Bad host or port number: " + x);
        }
      }

      // A PID was given on the command line.
      // Use the attach API to find the target's connector address, and
      // start it if needed.
      //
      if (pid != null) {
        try {
          return getURLForPid(pid);
        } catch (Exception x) {
          throwSyntaxError("cannot attach to target vm " + pid + ": " + x);
        }
      }

      final List<String> vmlist = new ArrayList();
      for (VirtualMachineDescriptor vd : VirtualMachine.list()) {
        vmlist.add(vd.id());
      }
      throwSyntaxError(
          "missing argument: " + "-port | -url | -pid | -list" + "\n\tRunning VMs are: " + vmlist);

      // Unreachable.
      return null;
    }
  private String getUserDir(com.sun.tools.attach.VirtualMachine vm) throws IOException {
    final String userDir = vm.getAgentProperties().getProperty(USER_DIR);
    if (userDir != null) return userDir;

    return vm.getSystemProperties().getProperty(USER_DIR);
  }