WhereAreYou.java

package org.objectweb.jonas.webapp.jonasadmin;

import javax.management.ObjectName;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionServlet;
import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.jmx.CatalinaObjectName;
import org.objectweb.jonas.jmx.JonasManagementRepr;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.jmx.ManagementException;
import org.objectweb.jonas.webapp.taglib.TreeControl;
import org.objectweb.jonas.webapp.taglib.TreeControlNode;

public class WhereAreYou {

// --------------------------------------------------------- Public Constants
    public final static String EXCEPTION_MBEANSERVER_NOTFOUND = "error.mbeanserver.notfound";
    public final static String EXCEPTION_JONASSERVER_NOTFOUND = "error.jonasserver.notfound";
    public final static String EXCEPTION_MBEAN_J2EEDOMAIN_NOTFOUND = "error.mbean.j2eedomain.notfound";
    public final static String EXCEPTION_MBEAN_J2EESERVER_NOTFOUND = "error.mbean.j2eeserver.notfound";

    public final static String SESSION_NAME = "WhereAreYou";

    // Constant environnement
    public final static String TAGS_IMAGES_ROOT_KEY = "tagsimagesroot";
    public final static String CONTEXT_MACRO = "${CONTEXT}";
    public final static String TREE_PAGE_REFRESH = "viewTree.do?select=";

    public final static String NODE_SEPARATOR = "*";

    // Deployment identification number
    public final static int DEPLOYMENT_EAR = 1;
    public final static int DEPLOYMENT_JAR = 2;
    public final static int DEPLOYMENT_WAR = 3;
    public final static int DEPLOYMENT_RAR = 4;
    public final static int DEPLOYMENT_DATASOURCE = 5;
    public final static int DEPLOYMENT_JMS = 6;
    public final static int DEPLOYMENT_MAIL = 7;

    // Deployment identification string
    public final static String DEPLOYMENT_STRING_EAR = "ear";
    public final static String DEPLOYMENT_STRING_JAR = "jar";
    public final static String DEPLOYMENT_STRING_WAR = "war";
    public final static String DEPLOYMENT_STRING_RAR = "rar";
    public final static String DEPLOYMENT_STRING_DATASOURCE = "datasource";
    public final static String DEPLOYMENT_STRING_JMS = "jms";
    public final static String DEPLOYMENT_STRING_MAILFACTORY = "mail";

// --------------------------------------------------------- Properties variable

    private String imagesRoot = null;
    private TreeControl treeControl = null;
    private boolean treeToRefresh = false;

    private String applicationJonasServerName = null;
    private int applicationServerPort = 0;
    private String applicationContextPath = null;

    private boolean currentApplicationJonasServerName = false;

    private boolean catalinaServer = false;
    private String currentCatalinaDomainName = null;
    private String currentCatalinaServiceName = null;
    private String currentCatalinaEngineName = null;
    private String currentCatalinaDefaultHostName = null;
    private boolean jettyServer = false;

    // J2EE Management information (used in construction of JSR77 ObjectNames)
    private ObjectName currentDomain = null;
    private ObjectName currentJonasServer = null;
    private String currentDomainName = null;
    private String currentJonasServerName = null;

    private int currentJonasDeploymentType = 0;

// --------------------------------------------------------- Constructor

    public WhereAreYou() {
    }

// --------------------------------------------------------- Public Methods

    public void initialize(ActionServlet p_Servlet, HttpServletRequest p_Request)
        throws JonasAdminException {
        // Tags Images Root directory
        String sImagesRoot = (String) p_Servlet.getServletConfig().getInitParameter(
            TAGS_IMAGES_ROOT_KEY);
        if (sImagesRoot != null) {
            sImagesRoot = JonasAdminJmx.replace(sImagesRoot, CONTEXT_MACRO
                , p_Request.getContextPath());
        }
        this.imagesRoot = sImagesRoot;
        // Initialize Servers properties
        refreshServers(p_Request);

    }

    public String getCurrentJonasServerName() {
        return currentJonasServerName;
    }

    public ObjectName getCurrentJonasServer() {
        return currentJonasServer;
    }

    public ObjectName getCurrentDomain() {
        return currentDomain;
    }

    public String getCurrentDomainName() {
        return currentDomainName;
    }

    public String getSelectedNameNode() {
        if (treeControl != null) {
            TreeControlNode oNode = treeControl.getSelected();
            if (oNode != null) {
                return oNode.getName();
            }
        }
        return null;
    }

    public String getUrlToRefreshSelectedNode(HttpServletRequest p_Request
        , HttpServletResponse p_Response) {
        if (treeControl != null) {
            TreeControlNode oNode = treeControl.getSelected();
            if (oNode != null) {
                // Disable refresh
                treeToRefresh = false;
                // Build URL refresh
                StringBuffer sb = new StringBuffer();
                sb.append(p_Request.getContextPath());
                sb.append("/");
                sb.append(TREE_PAGE_REFRESH);
                sb.append(oNode.getName());
                // Force the browser to refresh the tree (Netscape and Mozilla)
                sb.append("&s=");
                sb.append(Math.random());

                return p_Response.encodeURL(sb.toString());
            }
        }
        return null;
    }

    public void selectNameNode(String p_Name, boolean p_Expand) {
        if (treeControl != null) {
            // Changing node ?
            if (p_Name.equals(getSelectedNameNode()) == false) {
                // Change node
                treeControl.selectNode(p_Name);
                if (p_Expand == true) {
                    treeControl.expandSelectedParents();
                }
                treeToRefresh = true;
            }
            // Query node not found
            if ((getSelectedTreeControlNode() == null) && (p_Name != null) && (p_Name.length() > 0)) {
                // Try to select the parent node
                String s = p_Name.substring(0, p_Name.lastIndexOf(WhereAreYou.NODE_SEPARATOR));
                if ((s != null) && (s.length() > 0)) {
                    selectNameNode(s, p_Expand);
                }
            }
        }
    }

    public TreeControlNode getSelectedTreeControlNode() {
        if (treeControl != null) {
            return treeControl.getSelected();
        }
        return null;
    }

    public boolean isTreeToRefresh() {
        return treeToRefresh;
    }

    public void setTreeToRefresh(boolean treeToRefresh) {
        this.treeToRefresh = treeToRefresh;
    }

    public void refreshServers(HttpServletRequest p_Request)
        throws JonasAdminException {
        applicationServerPort = p_Request.getServerPort();
        applicationContextPath = p_Request.getContextPath();
        refreshCatalina(p_Request);
        refreshJetty(p_Request);
        refreshJonas(p_Request);
    }

    public void refreshCatalina(HttpServletRequest p_Request) {
        resetCatalina();
        try {
            String sServer = getServletServerName().toLowerCase();
            catalinaServer = (sServer.indexOf("tomcat") > -1);
            if (catalinaServer) {
                ObjectName onServer = JonasAdminJmx.getFirstMbean(CatalinaObjectName.catalinaServer());
                ObjectName[] aonServices = (ObjectName[]) JonasManagementRepr.getAttribute(onServer
                , "serviceNames");
                // Service : the first !
                currentCatalinaServiceName = aonServices[0].getKeyProperty("serviceName");
                // Domain
                currentCatalinaDomainName = aonServices[0].getDomain();
                // Engine
                currentCatalinaEngineName = currentCatalinaDomainName;
                ObjectName onEngine = CatalinaObjectName.catalinaEngine(currentCatalinaDomainName);
                // Default Host
                currentCatalinaDefaultHostName = (String) JonasManagementRepr.getAttribute(onEngine
                , "defaultHost");
            }
        } catch (Exception e) {
            // none
        }
    }

    public void refreshJetty(HttpServletRequest p_Request) {
        resetJetty();
        try {
            String sServer = getServletServerName().toLowerCase();
            jettyServer = (sServer.indexOf("jetty") > -1);
            if (jettyServer == true) {
                // none action
            }
        }
        catch (Exception e) {
            // none
        }
    }

    public void refreshJonas(HttpServletRequest p_Request)
        throws JonasAdminException {
        resetJonas();
        // Set J2EEDomain information
        currentDomain = JonasAdminJmx.getJ2eeDomainObjectName();
        if (currentDomain != null) {
            currentDomainName = currentDomain.getKeyProperty("name");
        }
        else {
            // Can't run jonasAdmin
            throw new JonasAdminException(EXCEPTION_MBEAN_J2EEDOMAIN_NOTFOUND);
        }
        // Set J2EEServer information
        currentJonasServer = JonasAdminJmx.getJ2eeServerObjectName(currentDomainName);
        if (currentJonasServer != null) {
            currentJonasServerName = currentJonasServer.getKeyProperty("name");
        }
        else {
            // Can't run jonasAdmin
            throw new JonasAdminException(EXCEPTION_MBEAN_J2EESERVER_NOTFOUND);
        }
        try {
            // Get the name of the Jonas Server who is running the application
            JProp oJProp = JProp.getInstance();
            applicationJonasServerName = oJProp.getValue(JProp.JONAS_NAME);
            // Detect if the current managed JOnAS server is the one where the application is running
            currentApplicationJonasServerName = applicationJonasServerName.equals(
                currentJonasServerName);
        }
        catch (Exception e) {
            // Current Jonas not found, can't run jonasAdmin
            throw new JonasAdminException(EXCEPTION_JONASSERVER_NOTFOUND, e.getMessage(), e);
        }
    }

    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("imagesRoot=[").append(imagesRoot).append("] ");
        sb.append("treeControl=[").append(treeControl).append("] ");
        sb.append("catalinaServer=[").append(catalinaServer).append("] ");
        return sb.toString();
    }

// --------------------------------------------------------- Protected Methods

    protected String getServletServerName() throws ManagementException {
        String servletServerName = (String) JonasManagementRepr.getAttribute(JonasObjectName.webContainerService()
            , "ServerName");
        return servletServerName;
    }

    protected void resetCatalina() {
        catalinaServer = false;
        currentCatalinaServiceName = null;
    }

    protected void resetJetty() {
        jettyServer = false;
    }

    protected void resetJonas() {
        applicationJonasServerName = null;
        currentApplicationJonasServerName = false;
        currentDomain = null;
        currentDomainName = null;
        currentJonasServer = null;
        currentJonasServerName = null;
    }

// --------------------------------------------------------- Properties Methods

    public String getImagesRoot() {
        return imagesRoot;
    }

    public TreeControl getTreeControl() {
        return treeControl;
    }

    public void setTreeControl(TreeControl treeControl) {
        this.treeControl = treeControl;
    }

    public boolean isCatalinaServer() {
        return catalinaServer;
    }

    public String getCurrentCatalinaServiceName() {
        return currentCatalinaServiceName;
    }

    public boolean isCurrentApplicationJonasServerName() {
        return currentApplicationJonasServerName;
    }

    public int getCurrentJonasDeploymentType() {
        return currentJonasDeploymentType;
    }

    public void setCurrentJonasDeploymentType(int currentJonasDeploymentType) {
        this.currentJonasDeploymentType = currentJonasDeploymentType;
    }

    public int getApplicationServerPort() {
        return applicationServerPort;
    }

    public String getApplicationJonasServerName() {
        return applicationJonasServerName;
    }

    public String getApplicationContextPath() {
        return applicationContextPath;
    }

    public String getCurrentCatalinaDefaultHostName() {
        return currentCatalinaDefaultHostName;
    }

    public String getCurrentCatalinaEngineName() {
        return currentCatalinaEngineName;
    }

    public String getCurrentCatalinaDomainName() {
        return currentCatalinaDomainName;
    }

    public boolean isJettyServer() {
        return jettyServer;
    }
}

---