package weblogic.diagnostics.examples;

import weblogic.diagnostics.context.DiagnosticContextHelper;

public class DiagnosticContextExample {  

  public static void main(String args[]) throws Exception {
    System.out.println("ContextId=" +
        DiagnosticContextHelper.getContextId());
    System.out.println("isDyedWith(DYE_0)=" + 
       DiagnosticContextHelper.isDyedWith(DiagnosticContextHelper.DYE_0));

    DiagnosticContextHelper.setDye(DiagnosticContextHelper.DYE_0, true);
    System.out.println("isDyedWith(DYE_0)=" + 
         DiagnosticContextHelper.isDyedWith(DiagnosticContextHelper.DYE_0));
  }
}

package weblogic.diagnostics.examples;

import weblogic.management.mbeanservers.runtime.RuntimeServiceMBean;

import javax.management.*;
import javax.management.remote.*;
import javax.naming.Context;
import java.util.*;

public class HarvesterMonitor {

  private static String accessorRuntimeMBeanName;
   private static ObjectName accessorRuntimeMBeanObjectName;

  private static String harvRuntimeMBeanName;
   private static ObjectName harvRuntimeMBeanObjectName;

  private static MBeanServerConnection rmbs;

  private static ObjectName getObjectName(String objectNameStr) {
     try { return new ObjectName(getCanonicalName(objectNameStr)); }
     catch (RuntimeException x) { throw x; }
     catch (Exception x) { x.printStackTrace(); throw new
                                RuntimeException(x); }
  }

  private static String getCanonicalName(String objectNameStr) {
     try { return new ObjectName(objectNameStr).getCanonicalName(); }
     catch (RuntimeException x) { throw x; }
     catch (Exception x) { x.printStackTrace(); throw new
                                 RuntimeException(x); }
  }

  private static String serverName;
   private static int port;
   private static String userName;
   private static String password;

  private static ArrayList typesToMonitor = null;

  public static void main(String[] args) throws Exception {

    if (args.length < 4) {
        System.out.println(
             "Usage: java weblogic.diagnostics.harvester.HarvesterMonitor " +
             "<serverName> <port> <userName> <password> [<types>]" +
              weblogic.utils.PlatformConstants.EOL +
              "   where <types> (optional) is a comma-separated list " +
              "of types to monitor.");
        System.exit(1);
    }

    serverName = args[0];
     port = Integer.parseInt(args[1]);
     userName = args[2];
     password = args[3];

    accessorRuntimeMBeanName = getCanonicalName(
         "com.bea:ServerRuntime=" + serverName +          ",Name=HarvestedDataArchive,Type=WLDFDataAccessRuntime" +          ",WLDFAccessRuntime=Accessor,WLDFRuntime=WLDFRuntime");
    accessorRuntimeMBeanObjectName = 
          getObjectName(accessorRuntimeMBeanName);

    harvRuntimeMBeanName = getCanonicalName(
        "com.bea:ServerRuntime=" + serverName +
        ",Name=WLDFHarvesterRuntime,Type=WLDFHarvesterRuntime" +
        ",WLDFRuntime=WLDFRuntime");
    harvRuntimeMBeanObjectName = getObjectName(harvRuntimeMBeanName);

    if (args.length > 4) {
      String typesStr = args[4];
      typesToMonitor = new ArrayList();
      int index;
      while ((index = typesStr.indexOf(",")) > 0) {
        String typeName = typesStr.substring(0,index).trim();
        typesToMonitor.add(typeName);
        typesStr = typesStr.substring(index+1);
      }
      typesToMonitor.add(typesStr.trim());
    }

    rmbs = getRuntimeMBeanServerConnection();

    new HarvesterMonitor().new HarvestCycleHandler();
    while(true) {Thread.sleep(100000);}
  }

  static protected String JNDI = "/jndi/";
  static public MBeanServerConnection getRuntimeMBeanServerConnection()
      throws Exception {

    JMXServiceURL serviceURL;
    serviceURL =
        new JMXServiceURL("t3",
        "localhost",
        port,
        JNDI + RuntimeServiceMBean.MBEANSERVER_JNDI_NAME);
    System.out.println("ServerName=" + serverName);
    System.out.println("URL=" + serviceURL);

    Hashtable h = new Hashtable();
    h.put(Context.SECURITY_PRINCIPAL, userName);
    h.put(Context.SECURITY_CREDENTIALS, password);
    h.put(JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES,
          "weblogic.management.remote");
    JMXConnector connector = JMXConnectorFactory.connect(serviceURL,h);
    return connector.getMBeanServerConnection();
  }

  class HarvestCycleHandler implements NotificationListener {
    // used to track harvest cycles

    private int timestampIndex;
    private int domainIndex;
    private int serverIndex;
    private int typeIndex;
    private int instNameIndex;
    private int attrNameIndex;
    private int attrTypeIndex;
    private int attrValueIndex;  

    long lastSampleTime = System.currentTimeMillis();

    HarvestCycleHandler() throws Exception{
      System.out.println("Harvester monitor started...");
      try {
        setUpRecordIndices();
        rmbs.addNotificationListener(harvRuntimeMBeanObjectName, 
                                     this, null, null);
      }
      catch (javax.management.InstanceNotFoundException x) {
        System.out.println("Cannot find JMX data. " +
                           "Is the server name correct?");
        System.exit(1);
      }
    }

    private void setUpRecordIndices() throws Exception {

      Map columnIndexMap = (Map)rmbs.getAttribute(
          accessorRuntimeMBeanObjectName, "ColumnIndexMap");

      timestampIndex =              ((Integer)columnIndexMap.get("TIMESTAMP")).intValue();
      domainIndex = 
            ((Integer)columnIndexMap.get("DOMAIN")).intValue();
      serverIndex = 
            ((Integer)columnIndexMap.get("SERVER")).intValue();
      typeIndex = 
            ((Integer)columnIndexMap.get("TYPE")).intValue();
      instNameIndex = 
            ((Integer)columnIndexMap.get("NAME")).intValue();
      attrNameIndex = 
            ((Integer)columnIndexMap.get("ATTRNAME")).intValue();
      attrTypeIndex = 
            ((Integer)columnIndexMap.get("ATTRTYPE")).intValue();
      attrValueIndex =              ((Integer)columnIndexMap.get("ATTRVALUE")).intValue();
    }

    public synchronized void handleNotification(Notification notification,
                                                Object handback) {
        System.out.println("\n------------------------------------------");
      long thisSampleTime = System.currentTimeMillis()+1;
      try {
        String lastTypeName = null;
        String lastInstName = null;
        String cursor = (String)rmbs.invoke(accessorRuntimeMBeanObjectName,
                        "openCursor",
                        new Object[]{new Long(lastSampleTime),
                        new Long(thisSampleTime), null},
                        new String[]{ "java.lang.Long",
                        "java.lang.Long", "java.lang.String" } );
        while (((Boolean)rmbs.invoke(accessorRuntimeMBeanObjectName,
                        "hasMoreData",
                        new Object[]{cursor},
                        new String[]{"java.lang.String"})).booleanValue()) {
          Object[] os = (Object[])rmbs.invoke(accessorRuntimeMBeanObjectName,
                        "fetch",
                        new Object[]{cursor},
                        new String[]{"java.lang.String"});
          for (int i = 0; i < os.length; i++) {
            Object[] values = (Object[])os[i];
            String typeName = (String)values[typeIndex];
            String instName = (String)values[instNameIndex];
            String attrName = (String)values[attrNameIndex];
            if (!typeName.equals(lastTypeName)) {
              if (typesToMonitor != null &&
                  !typesToMonitor.contains(typeName)) continue;
              System.out.println("\nType " + typeName);
              lastTypeName = typeName;
            }
            if (!instName.equals(lastInstName)) {
              System.out.println("\n  Instance " + instName);
              lastInstName = instName;
            }
            Object attrValue = values[attrValueIndex];
            System.out.println("    - " + attrName + "=" + attrValue);
          }
        }
        lastSampleTime = thisSampleTime;
      }
      catch (Exception e) {e.printStackTrace();}
    }
  }
}

package weblogic.diagnostics.examples;

import java.io.IOException;
import java.net.MalformedURLException;
import java.util.Hashtable;
import java.util.Iterator;
import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.naming.Context;

public class JMXAccessorExample {

  private static final String JNDI = "/jndi/";

  public static void main(String[] args) {
    try {
      if (args.length != 2) {
        System.err.println("Incorrect invocation. Correct usage is:\n" +
          "java weblogic.diagnostics.examples.JMXAccessorExample " +
          "<logicalName> <query>");
        System.exit(1);
      }
      String logicalName = args[0];
      String query = args[1];      

      MBeanServerConnection mbeanServerConnection =
        lookupMBeanServerConnection();
      ObjectName service = new
          ObjectName(weblogic.management.mbeanservers.runtime.RuntimeServiceMBean.OBJECT_NAME);
      ObjectName serverRuntime =
        (ObjectName) mbeanServerConnection.getAttribute(service,
         "ServerRuntime");
      ObjectName wldfRuntime =
        (ObjectName) mbeanServerConnection.getAttribute(serverRuntime,
         "WLDFRuntime");
      ObjectName wldfAccessRuntime =
        (ObjectName) mbeanServerConnection.getAttribute(wldfRuntime,
         "WLDFAccessRuntime");
      ObjectName wldfDataAccessRuntime =
        (ObjectName) mbeanServerConnection.invoke(wldfAccessRuntime,
         "lookupWLDFDataAccessRuntime", new Object[] {logicalName}, 
          new String[] {"java.lang.String"});

      String cursor =
         (String) mbeanServerConnection.invoke(wldfDataAccessRuntime,
          "openCursor", new Object[] {query}, 
          new String[] {"java.lang.String"});

      int fetchedCount = 0;
      do {
        Object[] rows =
         (Object[]) mbeanServerConnection.invoke(wldfDataAccessRuntime,
          "fetch", new Object[] {cursor}, 
          new String[] {"java.lang.String"});

        fetchedCount = rows.length;

        for (int i=0; i<rows.length; i++) {
         StringBuffer sb = new StringBuffer();
          Object[] cols = (Object[]) rows[i];
          for (int j=0; j<cols.length; j++) {
            sb.append("Index " + j + "=" + cols[j].toString() + " ");
          }
          System.out.println("Found row = " + sb.toString());
        }
      } while (fetchedCount > 0);

      mbeanServerConnection.invoke(wldfDataAccessRuntime,
          "closeCursor", new Object[] {cursor},
          new String[] {"java.lang.String"});

      } catch(Throwable th) {
      th.printStackTrace();
      System.exit(1);
    }
  }

   private static MBeanServerConnection lookupMBeanServerConnection ()
          throws Exception {

    // construct JMX service URL
    JMXServiceURL serviceURL;
    serviceURL = new JMXServiceURL("iiop", "localhost", 7001, 
        JNDI + "weblogic.management.mbeanservers.runtime");

    // Specify the user, password, and WebLogic provider package
    Hashtable h = new Hashtable();
    h.put(Context.SECURITY_PRINCIPAL,"weblogic");
    h.put(Context.SECURITY_CREDENTIALS,"weblogic");
    h.put(JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES,
          "weblogic.management.remote");
    // Get jmx connector 
    JMXConnector connector = JMXConnectorFactory.connect(serviceURL,h);

    // return MBean server connection class
    return connector.getMBeanServerConnection();

  } // End - lookupMBeanServerConnection
}