home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / javax / management / StandardMBean.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  13.9 KB  |  507 lines
  1. package javax.management;
  2.  
  3. import com.sun.jmx.mbeanserver.DescriptorCache;
  4. import com.sun.jmx.mbeanserver.Introspector;
  5. import com.sun.jmx.mbeanserver.MBeanSupport;
  6. import com.sun.jmx.mbeanserver.MXBeanSupport;
  7. import com.sun.jmx.mbeanserver.StandardMBeanSupport;
  8. import com.sun.jmx.trace.Trace;
  9. import java.io.PrintWriter;
  10. import java.io.StringWriter;
  11. import java.security.AccessController;
  12. import java.util.HashMap;
  13. import java.util.Map;
  14. import java.util.WeakHashMap;
  15. import javax.management.openmbean.OpenMBeanAttributeInfo;
  16. import javax.management.openmbean.OpenMBeanAttributeInfoSupport;
  17. import javax.management.openmbean.OpenMBeanConstructorInfo;
  18. import javax.management.openmbean.OpenMBeanConstructorInfoSupport;
  19. import javax.management.openmbean.OpenMBeanOperationInfo;
  20. import javax.management.openmbean.OpenMBeanOperationInfoSupport;
  21. import javax.management.openmbean.OpenMBeanParameterInfo;
  22. import javax.management.openmbean.OpenMBeanParameterInfoSupport;
  23.  
  24. public class StandardMBean implements DynamicMBean, MBeanRegistration {
  25.    private static final String dbgTag = "StandardMBean";
  26.    private static final DescriptorCache descriptors;
  27.    private volatile MBeanSupport<?> mbean;
  28.    private volatile MBeanInfo cachedMBeanInfo;
  29.    private static final Map<Class, Boolean> mbeanInfoSafeMap;
  30.  
  31.    private <T> void construct(T var1, Class<T> var2, boolean var3, boolean var4) throws NotCompliantMBeanException {
  32.       if (var1 == null) {
  33.          if (!var3) {
  34.             throw new IllegalArgumentException("implementation is null");
  35.          }
  36.  
  37.          var1 = this;
  38.       }
  39.  
  40.       if (var4) {
  41.          if (var2 == null) {
  42.             var2 = Introspector.getMXBeanInterface(var1.getClass());
  43.          }
  44.  
  45.          this.mbean = new MXBeanSupport(var1, var2);
  46.       } else {
  47.          if (var2 == null) {
  48.             var2 = Introspector.getStandardMBeanInterface(var1.getClass());
  49.          }
  50.  
  51.          this.mbean = new StandardMBeanSupport(var1, var2);
  52.       }
  53.  
  54.    }
  55.  
  56.    public <T> StandardMBean(T var1, Class<T> var2) throws NotCompliantMBeanException {
  57.       this.construct(var1, var2, false, false);
  58.    }
  59.  
  60.    protected StandardMBean(Class<?> var1) throws NotCompliantMBeanException {
  61.       this.construct((Object)null, var1, true, false);
  62.    }
  63.  
  64.    public <T> StandardMBean(T var1, Class<T> var2, boolean var3) {
  65.       try {
  66.          this.construct(var1, var2, false, var3);
  67.       } catch (NotCompliantMBeanException var5) {
  68.          throw new IllegalArgumentException(var5);
  69.       }
  70.    }
  71.  
  72.    protected StandardMBean(Class<?> var1, boolean var2) {
  73.       try {
  74.          this.construct((Object)null, var1, true, var2);
  75.       } catch (NotCompliantMBeanException var4) {
  76.          throw new IllegalArgumentException(var4);
  77.       }
  78.    }
  79.  
  80.    public void setImplementation(Object var1) throws NotCompliantMBeanException {
  81.       if (var1 == null) {
  82.          throw new IllegalArgumentException("implementation is null");
  83.       } else {
  84.          if (this.isMXBean()) {
  85.             this.mbean = new MXBeanSupport(var1, this.getMBeanInterface());
  86.          } else {
  87.             this.mbean = new StandardMBeanSupport(var1, this.getMBeanInterface());
  88.          }
  89.  
  90.       }
  91.    }
  92.  
  93.    public Object getImplementation() {
  94.       return this.mbean.getResource();
  95.    }
  96.  
  97.    public final Class<?> getMBeanInterface() {
  98.       return this.mbean.getMBeanInterface();
  99.    }
  100.  
  101.    public Class<?> getImplementationClass() {
  102.       return this.mbean.getResource().getClass();
  103.    }
  104.  
  105.    public Object getAttribute(String var1) throws AttributeNotFoundException, MBeanException, ReflectionException {
  106.       return this.mbean.getAttribute(var1);
  107.    }
  108.  
  109.    public void setAttribute(Attribute var1) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException {
  110.       this.mbean.setAttribute(var1);
  111.    }
  112.  
  113.    public AttributeList getAttributes(String[] var1) {
  114.       return this.mbean.getAttributes(var1);
  115.    }
  116.  
  117.    public AttributeList setAttributes(AttributeList var1) {
  118.       return this.mbean.setAttributes(var1);
  119.    }
  120.  
  121.    public Object invoke(String var1, Object[] var2, String[] var3) throws MBeanException, ReflectionException {
  122.       return this.mbean.invoke(var1, var2, var3);
  123.    }
  124.  
  125.    public MBeanInfo getMBeanInfo() {
  126.       try {
  127.          MBeanInfo var1 = this.getCachedMBeanInfo();
  128.          if (var1 != null) {
  129.             return var1;
  130.          }
  131.       } catch (RuntimeException var15) {
  132.          debug("getMBeanInfo", "failed to get cached MBeanInfo: " + var15);
  133.          debugX("getMBeanInfo", var15);
  134.       }
  135.  
  136.       if (isTraceOn()) {
  137.          trace("getMBeanInfo", "Building MBeanInfo for " + this.getImplementationClass().getName());
  138.       }
  139.  
  140.       MBeanSupport var16 = this.mbean;
  141.       MBeanInfo var2 = var16.getMBeanInfo();
  142.       Object var3 = var16.getResource();
  143.       boolean var4 = immutableInfo(this.getClass());
  144.       String var5 = this.getClassName(var2);
  145.       String var6 = this.getDescription(var2);
  146.       MBeanConstructorInfo[] var7 = this.getConstructors(var2, var3);
  147.       MBeanAttributeInfo[] var8 = this.getAttributes(var2);
  148.       MBeanOperationInfo[] var9 = this.getOperations(var2);
  149.       MBeanNotificationInfo[] var10 = this.getNotifications(var2);
  150.       Descriptor var11 = this.getDescriptor(var2, var4);
  151.       MBeanInfo var12 = new MBeanInfo(var5, var6, var8, var7, var9, var10, var11);
  152.  
  153.       try {
  154.          this.cacheMBeanInfo(var12);
  155.       } catch (RuntimeException var14) {
  156.          debug("cacheMBeanInfo", "failed to cache MBeanInfo: " + var14);
  157.          debugX("cacheMBeanInfo", var14);
  158.       }
  159.  
  160.       return var12;
  161.    }
  162.  
  163.    protected String getClassName(MBeanInfo var1) {
  164.       return var1 == null ? this.getImplementationClass().getName() : var1.getClassName();
  165.    }
  166.  
  167.    protected String getDescription(MBeanInfo var1) {
  168.       return var1 == null ? null : var1.getDescription();
  169.    }
  170.  
  171.    protected String getDescription(MBeanFeatureInfo var1) {
  172.       return var1 == null ? null : var1.getDescription();
  173.    }
  174.  
  175.    protected String getDescription(MBeanAttributeInfo var1) {
  176.       return this.getDescription((MBeanFeatureInfo)var1);
  177.    }
  178.  
  179.    protected String getDescription(MBeanConstructorInfo var1) {
  180.       return this.getDescription((MBeanFeatureInfo)var1);
  181.    }
  182.  
  183.    protected String getDescription(MBeanConstructorInfo var1, MBeanParameterInfo var2, int var3) {
  184.       return var2 == null ? null : var2.getDescription();
  185.    }
  186.  
  187.    protected String getParameterName(MBeanConstructorInfo var1, MBeanParameterInfo var2, int var3) {
  188.       return var2 == null ? null : var2.getName();
  189.    }
  190.  
  191.    protected String getDescription(MBeanOperationInfo var1) {
  192.       return this.getDescription((MBeanFeatureInfo)var1);
  193.    }
  194.  
  195.    protected int getImpact(MBeanOperationInfo var1) {
  196.       return var1 == null ? 3 : var1.getImpact();
  197.    }
  198.  
  199.    protected String getParameterName(MBeanOperationInfo var1, MBeanParameterInfo var2, int var3) {
  200.       return var2 == null ? null : var2.getName();
  201.    }
  202.  
  203.    protected String getDescription(MBeanOperationInfo var1, MBeanParameterInfo var2, int var3) {
  204.       return var2 == null ? null : var2.getDescription();
  205.    }
  206.  
  207.    protected MBeanConstructorInfo[] getConstructors(MBeanConstructorInfo[] var1, Object var2) {
  208.       if (var1 == null) {
  209.          return null;
  210.       } else {
  211.          return var2 != null && var2 != this ? null : var1;
  212.       }
  213.    }
  214.  
  215.    MBeanNotificationInfo[] getNotifications(MBeanInfo var1) {
  216.       return null;
  217.    }
  218.  
  219.    Descriptor getDescriptor(MBeanInfo var1, boolean var2) {
  220.       Object var3 = null;
  221.       ImmutableDescriptor var11;
  222.       if (var1 != null && var1.getDescriptor() != null && var1.getDescriptor().getFieldNames().length != 0) {
  223.          Descriptor var12 = var1.getDescriptor();
  224.          HashMap var13 = new HashMap();
  225.  
  226.          for(String var9 : var12.getFieldNames()) {
  227.             if (var9.equals("immutableInfo")) {
  228.                var13.put(var9, Boolean.toString(var2));
  229.             } else {
  230.                var13.put(var9, var12.getFieldValue(var9));
  231.             }
  232.          }
  233.  
  234.          var11 = new ImmutableDescriptor(var13);
  235.       } else {
  236.          String var4 = "interfaceClassName=" + this.getMBeanInterface().getName();
  237.          String var5 = "immutableInfo=" + var2;
  238.          var11 = new ImmutableDescriptor(new String[]{var4, var5});
  239.          var11 = descriptors.get(var11);
  240.       }
  241.  
  242.       return var11;
  243.    }
  244.  
  245.    protected MBeanInfo getCachedMBeanInfo() {
  246.       return this.cachedMBeanInfo;
  247.    }
  248.  
  249.    protected void cacheMBeanInfo(MBeanInfo var1) {
  250.       this.cachedMBeanInfo = var1;
  251.    }
  252.  
  253.    private boolean isMXBean() {
  254.       return this.mbean.isMXBean();
  255.    }
  256.  
  257.    private static <T> boolean identicalArrays(T[] var0, T[] var1) {
  258.       if (var0 == var1) {
  259.          return true;
  260.       } else if (var0 != null && var1 != null && var0.length == var1.length) {
  261.          for(int var2 = 0; var2 < var0.length; ++var2) {
  262.             if (var0[var2] != var1[var2]) {
  263.                return false;
  264.             }
  265.          }
  266.  
  267.          return true;
  268.       } else {
  269.          return false;
  270.       }
  271.    }
  272.  
  273.    private static <T> boolean equal(T var0, T var1) {
  274.       if (var0 == var1) {
  275.          return true;
  276.       } else {
  277.          return var0 != null && var1 != null ? var0.equals(var1) : false;
  278.       }
  279.    }
  280.  
  281.    private static MBeanParameterInfo customize(MBeanParameterInfo var0, String var1, String var2) {
  282.       if (equal(var1, var0.getName()) && equal(var2, var0.getDescription())) {
  283.          return var0;
  284.       } else if (var0 instanceof OpenMBeanParameterInfo) {
  285.          OpenMBeanParameterInfo var3 = (OpenMBeanParameterInfo)var0;
  286.          return new OpenMBeanParameterInfoSupport(var1, var2, var3.getOpenType(), var0.getDescriptor());
  287.       } else {
  288.          return new MBeanParameterInfo(var1, var0.getType(), var2, var0.getDescriptor());
  289.       }
  290.    }
  291.  
  292.    private static MBeanConstructorInfo customize(MBeanConstructorInfo var0, String var1, MBeanParameterInfo[] var2) {
  293.       if (equal(var1, var0.getDescription()) && identicalArrays(var2, var0.getSignature())) {
  294.          return var0;
  295.       } else if (var0 instanceof OpenMBeanConstructorInfo) {
  296.          OpenMBeanParameterInfo[] var3 = paramsToOpenParams(var2);
  297.          return new OpenMBeanConstructorInfoSupport(var0.getName(), var1, var3, var0.getDescriptor());
  298.       } else {
  299.          return new MBeanConstructorInfo(var0.getName(), var1, var2, var0.getDescriptor());
  300.       }
  301.    }
  302.  
  303.    private static MBeanOperationInfo customize(MBeanOperationInfo var0, String var1, MBeanParameterInfo[] var2, int var3) {
  304.       if (equal(var1, var0.getDescription()) && identicalArrays(var2, var0.getSignature()) && var3 == var0.getImpact()) {
  305.          return var0;
  306.       } else if (var0 instanceof OpenMBeanOperationInfo) {
  307.          OpenMBeanOperationInfo var4 = (OpenMBeanOperationInfo)var0;
  308.          OpenMBeanParameterInfo[] var5 = paramsToOpenParams(var2);
  309.          return new OpenMBeanOperationInfoSupport(var0.getName(), var1, var5, var4.getReturnOpenType(), var3, var0.getDescriptor());
  310.       } else {
  311.          return new MBeanOperationInfo(var0.getName(), var1, var2, var0.getReturnType(), var3, var0.getDescriptor());
  312.       }
  313.    }
  314.  
  315.    private static MBeanAttributeInfo customize(MBeanAttributeInfo var0, String var1) {
  316.       if (equal(var1, var0.getDescription())) {
  317.          return var0;
  318.       } else if (var0 instanceof OpenMBeanAttributeInfo) {
  319.          OpenMBeanAttributeInfo var2 = (OpenMBeanAttributeInfo)var0;
  320.          return new OpenMBeanAttributeInfoSupport(var0.getName(), var1, var2.getOpenType(), var0.isReadable(), var0.isWritable(), var0.isIs(), var0.getDescriptor());
  321.       } else {
  322.          return new MBeanAttributeInfo(var0.getName(), var0.getType(), var1, var0.isReadable(), var0.isWritable(), var0.isIs(), var0.getDescriptor());
  323.       }
  324.    }
  325.  
  326.    private static OpenMBeanParameterInfo[] paramsToOpenParams(MBeanParameterInfo[] var0) {
  327.       if (var0 instanceof OpenMBeanParameterInfo[]) {
  328.          return (OpenMBeanParameterInfo[])var0;
  329.       } else {
  330.          OpenMBeanParameterInfoSupport[] var1 = new OpenMBeanParameterInfoSupport[var0.length];
  331.          System.arraycopy(var0, 0, var1, 0, var0.length);
  332.          return var1;
  333.       }
  334.    }
  335.  
  336.    private MBeanConstructorInfo[] getConstructors(MBeanInfo var1, Object var2) {
  337.       MBeanConstructorInfo[] var3 = this.getConstructors(var1.getConstructors(), var2);
  338.       if (var3 == null) {
  339.          return null;
  340.       } else {
  341.          int var4 = var3.length;
  342.          MBeanConstructorInfo[] var5 = new MBeanConstructorInfo[var4];
  343.  
  344.          for(int var6 = 0; var6 < var4; ++var6) {
  345.             MBeanConstructorInfo var7 = var3[var6];
  346.             MBeanParameterInfo[] var8 = var7.getSignature();
  347.             MBeanParameterInfo[] var9;
  348.             if (var8 != null) {
  349.                int var10 = var8.length;
  350.                var9 = new MBeanParameterInfo[var10];
  351.  
  352.                for(int var11 = 0; var11 < var10; ++var11) {
  353.                   MBeanParameterInfo var12 = var8[var11];
  354.                   var9[var11] = customize(var12, this.getParameterName(var7, var12, var11), this.getDescription(var7, var12, var11));
  355.                }
  356.             } else {
  357.                var9 = null;
  358.             }
  359.  
  360.             var5[var6] = customize(var7, this.getDescription(var7), var9);
  361.          }
  362.  
  363.          return var5;
  364.       }
  365.    }
  366.  
  367.    private MBeanOperationInfo[] getOperations(MBeanInfo var1) {
  368.       MBeanOperationInfo[] var2 = var1.getOperations();
  369.       if (var2 == null) {
  370.          return null;
  371.       } else {
  372.          int var3 = var2.length;
  373.          MBeanOperationInfo[] var4 = new MBeanOperationInfo[var3];
  374.  
  375.          for(int var5 = 0; var5 < var3; ++var5) {
  376.             MBeanOperationInfo var6 = var2[var5];
  377.             MBeanParameterInfo[] var7 = var6.getSignature();
  378.             MBeanParameterInfo[] var8;
  379.             if (var7 != null) {
  380.                int var9 = var7.length;
  381.                var8 = new MBeanParameterInfo[var9];
  382.  
  383.                for(int var10 = 0; var10 < var9; ++var10) {
  384.                   MBeanParameterInfo var11 = var7[var10];
  385.                   var8[var10] = customize(var11, this.getParameterName(var6, var11, var10), this.getDescription(var6, var11, var10));
  386.                }
  387.             } else {
  388.                var8 = null;
  389.             }
  390.  
  391.             var4[var5] = customize(var6, this.getDescription(var6), var8, this.getImpact(var6));
  392.          }
  393.  
  394.          return var4;
  395.       }
  396.    }
  397.  
  398.    private MBeanAttributeInfo[] getAttributes(MBeanInfo var1) {
  399.       MBeanAttributeInfo[] var2 = var1.getAttributes();
  400.       if (var2 == null) {
  401.          return null;
  402.       } else {
  403.          int var4 = var2.length;
  404.          MBeanAttributeInfo[] var3 = new MBeanAttributeInfo[var4];
  405.  
  406.          for(int var5 = 0; var5 < var4; ++var5) {
  407.             MBeanAttributeInfo var6 = var2[var5];
  408.             var3[var5] = customize(var6, this.getDescription(var6));
  409.          }
  410.  
  411.          return var3;
  412.       }
  413.    }
  414.  
  415.    public ObjectName preRegister(MBeanServer var1, ObjectName var2) throws Exception {
  416.       this.mbean.register(var1, var2);
  417.       return var2;
  418.    }
  419.  
  420.    public void postRegister(Boolean var1) {
  421.       if (!var1) {
  422.          this.mbean.unregister();
  423.       }
  424.  
  425.    }
  426.  
  427.    public void preDeregister() throws Exception {
  428.    }
  429.  
  430.    public void postDeregister() {
  431.       this.mbean.unregister();
  432.    }
  433.  
  434.    static boolean immutableInfo(Class<? extends StandardMBean> var0) {
  435.       if (var0 != StandardMBean.class && var0 != StandardEmitterMBean.class) {
  436.          synchronized(mbeanInfoSafeMap) {
  437.             Boolean var2 = (Boolean)mbeanInfoSafeMap.get(var0);
  438.             if (var2 == null) {
  439.                try {
  440.                   MBeanInfoSafeAction var3 = new MBeanInfoSafeAction(var0);
  441.                   var2 = (Boolean)AccessController.doPrivileged(var3);
  442.                } catch (Exception var5) {
  443.                   var2 = false;
  444.                }
  445.  
  446.                mbeanInfoSafeMap.put(var0, var2);
  447.             }
  448.  
  449.             return var2;
  450.          }
  451.       } else {
  452.          return true;
  453.       }
  454.    }
  455.  
  456.    static boolean overrides(Class<?> var0, Class<?> var1, String var2, Class<?>... var3) {
  457.       for(Class var4 = var0; var4 != var1; var4 = var4.getSuperclass()) {
  458.          try {
  459.             var4.getDeclaredMethod(var2, var3);
  460.             return true;
  461.          }
  462.       }
  463.  
  464.       return false;
  465.    }
  466.  
  467.    private static boolean isTraceOn() {
  468.       return Trace.isSelected(1, 16);
  469.    }
  470.  
  471.    private static void trace(String var0, String var1, String var2) {
  472.       Trace.send(1, 16, var0, var1, var2);
  473.    }
  474.  
  475.    private static void trace(String var0, String var1) {
  476.       trace("StandardMBean", var0, var1);
  477.    }
  478.  
  479.    private static boolean isDebugOn() {
  480.       return Trace.isSelected(2, 16);
  481.    }
  482.  
  483.    private static void debug(String var0, String var1, String var2) {
  484.       Trace.send(2, 16, var0, var1, var2);
  485.    }
  486.  
  487.    private static void debug(String var0, String var1) {
  488.       debug("StandardMBean", var0, var1);
  489.    }
  490.  
  491.    private static void debugX(String var0, Throwable var1) {
  492.       if (isDebugOn()) {
  493.          StringWriter var2 = new StringWriter();
  494.          var1.printStackTrace(new PrintWriter(var2));
  495.          String var3 = var2.toString();
  496.          debug("StandardMBean", var0, "Exception caught in " + var0 + "(): " + var1);
  497.          debug("StandardMBean", var0, var3);
  498.       }
  499.  
  500.    }
  501.  
  502.    static {
  503.       descriptors = DescriptorCache.getInstance(JMX.proof);
  504.       mbeanInfoSafeMap = new WeakHashMap();
  505.    }
  506. }
  507.