J2EEServer.java

package org.objectweb.jonas.server;

// Java imports
import java.util.ArrayList;
import java.util.List;

import javax.management.JMException;
import javax.management.MBeanServer;
import javax.management.MBeanServerNotification;
import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.container.EJBService;
import org.objectweb.jonas.ear.EarService;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.management.AttributeAddNotification;
import org.objectweb.jonas.management.AttributeRemoveNotification;
import org.objectweb.jonas.management.ListenerJavaBean;
import org.objectweb.jonas.management.ReconfigException;
import org.objectweb.jonas.management.j2eemanagement.J2EEManagedObject;
import org.objectweb.jonas.resource.ResourceService;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.jonas.web.JWebContainerService;
import org.objectweb.jonas_timer.TimerEvent;
import org.objectweb.jonas_timer.TimerEventListener;
import org.objectweb.jonas_timer.TimerManager;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class J2EEServer extends J2EEManagedObject implements TimerEventListener, NotificationListener {
    private Server server = null;
    private String serverName = null;
    private String serverVersion = null;
    private String serverVendor = null;
    private String protocols = null;
    private ArrayList deployedObjects = null;
    private ArrayList resources = null;
    private ArrayList javaVMs = null;
    private boolean activated = true;

    private int sizeTableMeasures = 120;
    private int range = 10;
    private Long[] tableMeasures;
    private long maxtotalmemory;
    private TimerEvent mytimer = null;

    private static Logger mgtLogger = Log.getLogger(Log.JONAS_MANAGEMENT_PREFIX);
    private static Logger evtLogger = Log.getLogger(Log.JONAS_MANAGEMENT_EVENT_PREFIX);

    // sequence number needed when sending notifications
    private long sequenceNumber = 0;

    private ListenerJavaBean myListener = null;

    // Services used to deploy J2EE modules and applications
    private EJBService ejbService = null;
    private EarService earService = null;
    private ResourceService rarService = null;
    private JWebContainerService warService = null;
    
    private MBeanServer jmxServer = null;

    public J2EEServer(String objectName, Server server, String serverName, String serverVersion
        , String serverVendor, String protocols) {
        super(objectName);
        this.server = server;
        this.serverName = serverName;
        this.serverVersion = serverVersion;
        this.serverVendor = serverVendor;
        this.protocols = protocols;
        initTable();
        deployedObjects = new ArrayList();
        resources = new ArrayList();
        javaVMs = new ArrayList();
        //Launch Timer
        mytimer = TimerManager.getInstance().addTimerMs(this, range * 1000, new Integer(1), true);
        // Get services references
        // In case one of these services is not running, a ServiceException is thrown
        // No exception treatement is provided, only keep reference null
        try {
            ejbService = (EJBService) ServiceManager.getInstance().getEjbService();
        } catch (Exception e) {
        }
        try {
            earService = (EarService) ServiceManager.getInstance().getEarService();
        } catch (Exception e) {
        }
        try {
            rarService = (ResourceService) ServiceManager.getInstance().getRarService();
        } catch (Exception e) {
        }
        try {
            warService = (JWebContainerService) ServiceManager.getInstance().getWebContainerService();
        } catch (Exception e) {
        }
        try {
            JmxService jmxService = (JmxService) ServiceManager.getInstance().getJmxService();
            jmxServer = jmxService.getJmxServer();
        } catch (Exception e) {
        }
        // Add myself as listner to  MBeanServerNotifications. Use for this the MBeanServerDelegate ObjectName as
        // argument in the addNotificationListener method (see JMX API for more info).
        // Use null NotificationFilter and null handback object.
        try {
            ObjectName delegate = new ObjectName("JMImplementation:type=MBeanServerDelegate");
            jmxServer.addNotificationListener(delegate, this, null, null);
        } catch (JMException me) {
            // MalformedObjectNameException should not occur if the JMX implementation is correct
            // InstanceNotFoundException should not occur as we use MBeanServerDelegate ObjectName
            throw new ReconfigException("ReconfigManager can't listen to MBeanServerNotifications because of exception: " + me.toString());
        }
    }

    public String getServerName() {
        return serverName;
    }

    public String getServerVersion() {
        return serverVersion;
    }

    public String getServerVendor() {
        return serverVendor;
    }

    public List getDeployedObjects() {
        return deployedObjects;
    }

    public void addDeployedObject(String objectName) {
        deployedObjects.add(objectName);
    }

    public void removeDeployedObject(String objectName) {
        deployedObjects.remove(objectName);
    }

    public List getResources() {
        return resources;
    }

    public List getJavaVMs() {
        return javaVMs;
    }

    public void addJavaVM(String objectName) {
        javaVMs.add(objectName);
    }

    public String getProtocols() {
        return protocols;
    }

    public void stop()
        throws Exception {
        server.stop();
    }

    public void runGC() {
        Runtime.getRuntime().gc();
    }

    public long getCurrentUsedMemory() {
        return usedMemory();
    }

    public long getCurrentTotalMemory() {
        return totalMemory();
    }

    public void setRange(int range) {
        if (this.range != range) {
            synchronized (this) {
                if (range < 10) {
                    throw new IllegalArgumentException("range could not be < 10");
                }
                this.range = range;
                // reset table values
                initTable();
                mytimer.change(this.range * 1000, new Integer(1));
            }
        }
    }

    public int getRange() {
        return range;
    }

    public void setSizeTableMeasures(int sizeMeasuresTable) {
        if (sizeMeasuresTable != this.sizeTableMeasures) {
            synchronized (this) {
                if (sizeMeasuresTable <= 1) {
                    throw new IllegalArgumentException("number of measures could not be <= 1");
                }
                this.sizeTableMeasures = sizeMeasuresTable;
                initTable();
            }
        }
    }

    public int getSizeTableMeasures() {
        return sizeTableMeasures;
    }

    public Long[] getTableMeasures() {
        return tableMeasures;
    }

    // ===============================================================
    // TimerEventListener implementation
    // ===============================================================
    public void timeoutExpired(Object arg) {
        int argvalue = ((Integer) arg).intValue();
        switch (argvalue) {
            case 1:

                //timeout expired
                long uvalue = usedMemory();
                long tmvalue = totalMemory();

                // put the max total memory
                if (tmvalue > maxtotalmemory) {
                    maxtotalmemory = tmvalue;
                }
                for (int i = 0; i < tableMeasures.length; i++) {
                    if (i != tableMeasures.length - 1) {
                        tableMeasures[i] = tableMeasures[i + 1];
                    } else {
                        tableMeasures[i] = new Long(uvalue);
                    }
                }
                break;
            default:

                //timeoutExpired do nothing;
                break;
        }
    }

    public void setActivated(boolean pActivated) {
        if (pActivated) {
            if (!activated) {
                synchronized (this) {
                    activated = true;
                    initTable();
                }
                // launch timer
                mytimer = TimerManager.getInstance().addTimerMs(this, range * 1000, (Object) new Integer(1), true);
            }
        } else {
            if (activated) {
                synchronized (this) {
                    activated = false;
                    initTable();
                    // stop timer
                    mytimer.stop();
                    mytimer.unset();
                }
            }
        }
    }

    public boolean isActivated() {
        return activated;
    }

    private long usedMemory() {
        long result = -1;
        while (result < 0) {
            result = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        }

        return result / 1000;
    }

    private long totalMemory() {
        return Runtime.getRuntime().totalMemory() / 1000;
    }

    private void initTable() {
        tableMeasures = new Long[sizeTableMeasures];
        // init max totalmemory
        maxtotalmemory = totalMemory();
        for (int i = 0; i < tableMeasures.length; i++) {
            tableMeasures[i] = new Long(0);
        }
        // init the first value
        tableMeasures[tableMeasures.length - 1] = new Long(usedMemory());
    }

    public String deployJar(String fileName) throws Exception {
        if (ejbService != null) {
            return ejbService.createContainer(fileName);
        } else {
            throw new Exception("EJB Container service not started");
        }
    }

    public Boolean isJarDeployed(String fileName) throws Exception {
        if (ejbService != null) {
            return ejbService.isJarDeployed(fileName);
        } else {
            throw new Exception("EJB Container service not started");
        }
    }

    public void unDeployJar(String fileName) throws Exception {
        if (ejbService != null) {
            ejbService.removeContainer(fileName);
        } else {
            throw new Exception("EJB Container service not started");
        }
    }

    public Boolean isWarDeployed(String fileName) throws Exception {
        if (warService != null) {
            return new Boolean(warService.isWarLoaded(fileName));
        } else {
            throw new Exception("WEB Container service not started");
        }
    }

    public void deployWar(String fileName) throws Exception {
        if (warService != null) {
            warService.registerWarMBean(fileName);
        } else {
            throw new Exception("Web Container service not started");
        }
    }


    public void unDeployWar(String fileName) throws Exception {
        if (warService != null) {
            warService.unRegisterWarMBean(fileName);
        } else {
            throw new Exception("Web Container service not started");
        }
    }
    public String deployEar(String fileName) throws Exception {
        if (earService != null) {
            return earService.deployEar(fileName);
        } else {
            throw new Exception("EAR Container service not started");
        }
    }

    public Boolean isEarDeployed(String fileName) throws Exception {
        if (earService != null) {
            return earService.isEarDeployed(fileName);
        } else {
            throw new Exception("EAR Container service not started");
        }
    }

    public void unDeployEar(String fileName) throws Exception {
        if (earService != null) {
            earService.unDeployEar(fileName);
        } else {
            throw new Exception("EAR Container service not started");
        }
    }

    public String deployRar(String fileName) throws Exception {
        if (rarService != null) {
            return rarService.deployRar(fileName);
        } else {
            throw new Exception("Resource service not started");
        }
    }

    public Boolean isRarDeployed(String fileName) throws Exception {
        if (rarService != null) {
            return rarService.isRarDeployed(fileName);
        } else {
            throw new Exception("Resource service not started");
        }
    }

    public void unDeployRar(String fileName) throws Exception {
        if (rarService != null) {
            rarService.unDeployRar(fileName);
        } else {
            throw new Exception("Resource service not started");
        }
    }

    public void addResource(String pObjectName) {
        synchronized (resources) {
            if (resources.contains(pObjectName)) {
                if (mgtLogger.isLoggable(BasicLevel.DEBUG)) {
                    mgtLogger.log(BasicLevel.DEBUG
                        , "The object name: " + pObjectName + " is already in the resources list");
                }
            } else {
                // Add
                resources.add(pObjectName);
                // Send the notification
                AttributeAddNotification notification = new AttributeAddNotification(getObjectName()
                    , sequenceNumber++, System.currentTimeMillis(), "", "resource"
                    , pObjectName.toString());
                sendNotification(notification);
                if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                    evtLogger.log(BasicLevel.DEBUG
                        , "AttributeAddNotification emitted: resource added to the J2EEServer: "
                        + pObjectName.toString());
                }
            }
        }
    }

    public String removeResource(String pObjectName) {
        String sRet = null;
        synchronized (resources) {
            int index = resources.indexOf(pObjectName);
            if (index > -1) {
                // Remove
                sRet = (String) resources.remove(index);
                // Send the notification
                AttributeRemoveNotification notification = new AttributeRemoveNotification(
                    getObjectName(), sequenceNumber++, System.currentTimeMillis(), "", "resource"
                    , pObjectName.toString());
                sendNotification(notification);
                if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                    evtLogger.log(BasicLevel.DEBUG
                        , "AttributeRemoveNotification emitted: resource removed from the J2EEServer: "
                        + pObjectName.toString());
                }
            }
        }
        return sRet;
    }

    public void sendNotification(Notification notification) {
        // if registered listener(s)
        if (myListener != null) {
            NotificationListener listener = myListener.getListener();
            Object handback = myListener.getHandback();
            listener.handleNotification(notification, handback);
            if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                evtLogger.log(BasicLevel.DEBUG, "Notification sent");
            }
        }
    }

    public void addNotificationListener(NotificationListener listner, NotificationFilter filter
        , java.lang.Object handback)
        throws java.lang.IllegalArgumentException {
        // Create new listener
        ListenerJavaBean lmb = new ListenerJavaBean(listner, filter, handback);
        myListener = lmb;
        if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
            evtLogger.log(BasicLevel.DEBUG
                , "Listener added for J2EEServer MBean: " + getObjectName().toString());
            if (handback != null) {
                evtLogger.log(BasicLevel.DEBUG, " - with handback: " + handback.toString());
            }
        }
    }
    public void handleNotification(Notification notification, java.lang.Object handback) {
        if (notification instanceof MBeanServerNotification) {
            // This notification is sent by the jmx server.
            //
            // ObjectName of the MBean that caused the notification
            ObjectName causeObjectName = ((MBeanServerNotification) notification).getMBeanName();
            String causeJ2eeType = causeObjectName.getKeyProperty("j2eeType");
            if (causeJ2eeType != null) {
                // The MBean that caused the notification is a J2EEManagedObject
                // Check for server name being the current server name
                String serverName = causeObjectName.getKeyProperty("J2EEServer");
                if (serverName != null) {
                    if (!serverName.equals(getServerName())) {
                        return;
                    }
                } else {
                    return;
                }
                // Check for J2EEResource MBeans
                boolean j2eeResource = false;
                if (causeJ2eeType.equals("JavaMailResource")
                    || causeJ2eeType.equals("JNDIResource")
                    || causeJ2eeType.equals("JDBCResource")
                    || causeJ2eeType.equals("JMSResource")
                    || causeJ2eeType.equals("JTAResource")
                    || causeJ2eeType.equals("JCAResource")
                    || causeJ2eeType.equals("RMIIIOPResource")
                    || causeJ2eeType.equals("URLResource")) {
                    j2eeResource = true;
                }
                if (j2eeResource) {
                    String notificationType = notification.getType();
                    handleResourceNotification(causeObjectName, notificationType);
                }
                // Check for J2EEDeployedObjects
                boolean j2eeDeployed = false;
                if (causeJ2eeType.equals("J2EEApplication")
                    || causeJ2eeType.equals("AppClientModule")
                    || causeJ2eeType.equals("EJBModule")
                    || causeJ2eeType.equals("WebModule")
                    || causeJ2eeType.equals("ResourceAdapterModule")) {
                    j2eeDeployed = true;
                }
                if (j2eeDeployed) {
                    String notificationType = notification.getType();
                    handleDeployedNotification(causeObjectName, notificationType);
                }
            }
        }
    }
    private void handleResourceNotification(ObjectName resourceObjectName, String notificationType) {
        if (notificationType.equals(MBeanServerNotification.REGISTRATION_NOTIFICATION)) {
            addResource(resourceObjectName.toString());
            if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                evtLogger.log(BasicLevel.DEBUG, "Resource " + resourceObjectName.toString() + " added to J2EEServer " + getServerName());
            }
        } else if (notificationType.equals(MBeanServerNotification.UNREGISTRATION_NOTIFICATION)) {
            removeResource(resourceObjectName.toString());
            if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                evtLogger.log(BasicLevel.DEBUG, "Resource " + resourceObjectName.toString() + " removed from J2EEServer " + getServerName());
            }
        }
    }
    private void handleDeployedNotification(ObjectName deployedObjectName, String notificationType) {
        if (notificationType.equals(MBeanServerNotification.REGISTRATION_NOTIFICATION)) {
            addDeployedObject(deployedObjectName.toString());
            if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                evtLogger.log(BasicLevel.DEBUG, "J2EEDeployedObject " + deployedObjectName.toString() + " added to J2EEServer " + getServerName());
            }
        } else if (notificationType.equals(MBeanServerNotification.UNREGISTRATION_NOTIFICATION)) {
            removeDeployedObject(deployedObjectName.toString());
            if (evtLogger.isLoggable(BasicLevel.DEBUG)) {
                evtLogger.log(BasicLevel.DEBUG, "J2EEDeployedObject " + deployedObjectName.toString() + " removed from J2EEServer " + getServerName());
            }
        }
    }
}

---