    001    package org.apache.turbine.util;
    002
    003
    004    /*
    005     * Licensed to the Apache Software Foundation (ASF) under one
    006     * or more contributor license agreements.  See the NOTICE file
    007     * distributed with this work for additional information
    008     * regarding copyright ownership.  The ASF licenses this file
    009     * to you under the Apache License, Version 2.0 (the
    010     * "License"); you may not use this file except in compliance
    011     * with the License.  You may obtain a copy of the License at
    012     *
    013     *   http://www.apache.org/licenses/LICENSE-2.0
    014     *
    015     * Unless required by applicable law or agreed to in writing,
    016     * software distributed under the License is distributed on an
    017     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    018     * KIND, either express or implied.  See the License for the
    019     * specific language governing permissions and limitations
    020     * under the License.
    021     */
    022
    023
    024    import javax.servlet.http.HttpServletRequest;
    025
    026    import org.apache.commons.lang.StringUtils;
    027
    028    import org.apache.commons.logging.Log;
    029    import org.apache.commons.logging.LogFactory;
    030
    031    import org.apache.turbine.util.uri.URIConstants;
    032
    033    /**
    034     * Holds basic server information under which Turbine is running.
    035     * This class is accessable via the RunData object within the Turbine
    036     * system.  You can also use it as a placeholder for this information
    037     * if you are only emulating a servlet system.
    038     *
    039     * @author <a href="mailto:burton@apache.org">Kevin A. Burton</a>
    040     * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
    041     * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
    042     * @version $Id: ServerData.java 615328 2008-01-25 20:25:05Z tv $
    043     */
    044    public class ServerData
    045    {
    046        /** Cached serverName, */
    047        private String serverName = null;
    048
    049        /** Cached serverPort. */
    050        private int serverPort = 0;
    051
    052        /** Cached serverScheme. */
    053        private String serverScheme = null;
    054
    055        /** Cached script name. */
    056        private String  scriptName = null;
    057
    058        /** Cached context path. */
    059        private String  contextPath = null;
    060
    061        /** Logging */
    062        private static Log log = LogFactory.getLog(ServerData.class);
    063
    064        /**
    065         * Constructor.
    066         *
    067         * @param serverName The server name.
    068         * @param serverPort The server port.
    069         * @param serverScheme The server scheme.
    070         * @param scriptName The script name.
    071         * @param contextPath The context Path
    072         */
    073        public ServerData(String serverName,
    074            int serverPort,
    075            String serverScheme,
    076            String scriptName,
    077            String contextPath)
    078        {
    079            if (log.isDebugEnabled())
    080            {
    081                StringBuffer sb = new StringBuffer();
    082                sb.append("Constructor(");
    083                sb.append(serverName);
    084                sb.append(", ");
    085                sb.append(serverPort);
    086                sb.append(", ");
    087                sb.append(serverScheme);
    088                sb.append(", ");
    089                sb.append(scriptName);
    090                sb.append(", ");
    091                sb.append(contextPath);
    092                sb.append(")");
    093                log.debug(sb.toString());
    094            }
    095
    096            setServerName(serverName);
    097            setServerPort(serverPort);
    098            setServerScheme(serverScheme);
    099            setScriptName(scriptName);
    100            setContextPath(contextPath);
    101        }
    102
    103        /**
    104         * Copy-Constructor
    105         *
    106         * @param serverData A ServerData Object
    107         */
    108        public ServerData(ServerData serverData)
    109        {
    110            log.debug("Copy Constructor(" + serverData + ")");
    111
    112            setServerName(serverData.getServerName());
    113            setServerPort(serverData.getServerPort());
    114            setServerScheme(serverData.getServerScheme());
    115            setScriptName(serverData.getScriptName());
    116            setContextPath(serverData.getContextPath());
    117        }
    118
    119        /**
    120         * A C'tor that takes a HTTP Request object and
    121         * builds the server data from its contents
    122         *
    123         * @param req The HTTP Request
    124         */
    125        public ServerData(HttpServletRequest req)
    126        {
    127            setServerName(req.getServerName());
    128            setServerPort(req.getServerPort());
    129            setServerScheme(req.getScheme());
    130            setScriptName(req.getServletPath());
    131            setContextPath(req.getContextPath());
    132        }
    133
    134        /**
    135         * generates a new Object with the same values as this one.
    136         *
    137         * @return A cloned object.
    138         */
    139        public Object clone()
    140        {
    141            log.debug("clone()");
    142            return new ServerData(this);
    143        }
    144
    145        /**
    146         * Get the name of the server.
    147         *
    148         * @return A String.
    149         */
    150        public String getServerName()
    151        {
    152            return StringUtils.isEmpty(serverName) ? "" : serverName;
    153        }
    154
    155        /**
    156         * Sets the cached serverName.
    157         *
    158         * @param serverName the server name.
    159         */
    160        public void setServerName(String serverName)
    161        {
    162            log.debug("setServerName(" + serverName + ")");
    163            this.serverName = serverName;
    164        }
    165
    166        /**
    167         * Get the server port.
    168         *
    169         * @return the server port.
    170         */
    171        public int getServerPort()
    172        {
    173            return this.serverPort;
    174        }
    175
    176        /**
    177         * Sets the cached serverPort.
    178         *
    179         * @param serverPort the server port.
    180         */
    181        public void setServerPort(int serverPort)
    182        {
    183            log.debug("setServerPort(" + serverPort + ")");
    184            this.serverPort = serverPort;
    185        }
    186
    187        /**
    188         * Get the server scheme.
    189         *
    190         * @return the server scheme.
    191         */
    192        public String getServerScheme()
    193        {
    194            return StringUtils.isEmpty(serverScheme) ? "" : serverScheme;
    195        }
    196
    197        /**
    198         * Sets the cached serverScheme.
    199         *
    200         * @param serverScheme the server scheme.
    201         */
    202        public void setServerScheme(String serverScheme)
    203        {
    204            log.debug("setServerScheme(" + serverScheme + ")");
    205            this.serverScheme = serverScheme;
    206        }
    207
    208        /**
    209         * Get the script name
    210         *
    211         * @return the script name.
    212         */
    213        public String getScriptName()
    214        {
    215            return StringUtils.isEmpty(scriptName) ? "" : scriptName;
    216        }
    217
    218        /**
    219         * Set the script name.
    220         *
    221         * @param scriptName the script name.
    222         */
    223        public void setScriptName(String scriptName)
    224        {
    225            log.debug("setScriptName(" + scriptName + ")");
    226            this.scriptName = scriptName;
    227        }
    228
    229        /**
    230         * Get the context path.
    231         *
    232         * @return the context path.
    233         */
    234        public String getContextPath()
    235        {
    236            return StringUtils.isEmpty(contextPath) ? "" : contextPath;
    237        }
    238
    239        /**
    240         * Set the context path.
    241         *
    242         * @param contextPath A String.
    243         */
    244        public void setContextPath(String contextPath)
    245        {
    246            log.debug("setContextPath(" + contextPath + ")");
    247            this.contextPath = contextPath;
    248        }
    249
    250        /**
    251         * Appends the Host URL to the supplied StringBuffer.
    252         *
    253         * @param url A StringBuffer object
    254         */
    255        public void getHostUrl(StringBuffer url)
    256        {
    257            url.append(getServerScheme());
    258            url.append("://");
    259            url.append(getServerName());
    260            if ((getServerScheme().equals(URIConstants.HTTP)
    261                    && getServerPort() != URIConstants.HTTP_PORT)
    262                ||
    263                (getServerScheme().equals(URIConstants.HTTPS)
    264                    && getServerPort() != URIConstants.HTTPS_PORT)
    265                )
    266            {
    267                url.append(":");
    268                url.append(getServerPort());
    269            }
    270        }
    271
    272        /**
    273         * Returns this object as an URL.
    274         *
    275         * @return The contents of this object as a String
    276         */
    277        public String toString()
    278        {
    279            StringBuffer url = new StringBuffer();
    280
    281            getHostUrl(url);
    282
    283            url.append(getContextPath());
    284            url.append(getScriptName());
    285            return url.toString();
    286        }
    287    }