/*
* Copyright 2000-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jetspeed.services.webpage;
// java.util
import java.util.Properties;
import java.util.Collection;
// java.io
import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
// javax.servlet
import javax.servlet.http.*;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletConfig;
// velocity
import org.apache.velocity.Template;
import org.apache.velocity.context.Context;
import org.apache.velocity.servlet.VelocityServlet;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.apache.velocity.exception.ParseErrorException;
/**
*
* WebPageConsoleServlet is the main servlet entry point for the WebPage console.
*
*/
public class WebPageConsoleServlet extends VelocityServlet
{
private String servletPath = null;
private String proxyRoot = null;
/*
* Request Handler for a Velocity servlet. Includes the context.
*
* @param request Servlet request.
* @param response Servlet response.
* @context the velocity request context.
* @exception IOException a servlet exception.
* @exception ServletException a servlet exception.
*
* @return The newly merged template.
*/
public Template handleRequest( HttpServletRequest request,
HttpServletResponse response,
Context ctx )
{
if (servletPath == null)
{
servletPath = request.getServletPath();
proxyRoot = getProxyHost(request);
}
boolean online = WebPageManager.isInit();
if (online == false)
{
bootStrapProxy(request, response); // forward
}
String action = request.getParameter("action");
String template;
if (action == null)
template = sessions(ctx);
else if (action.equals("details"))
template = elementSessions(ctx, request);
else if (action.equals("test"))
template = test(ctx, request);
else if (action.equals("kill"))
template = kill(ctx, request);
else if (action.equals("killne"))
template = killne(ctx);
else if (action.equals("clear"))
template = clear(ctx);
else
template = sessions(ctx);
Template outty = null;
try
{
outty = getTemplate(template);
}
catch( ParseErrorException pee )
{
System.out.println("WebPageConsoleServlet : parse error for template " + pee);
}
catch( ResourceNotFoundException rnfe )
{
System.out.println("WebPageConsoleServlet : template not found " + rnfe);
}
catch( Exception e )
{
System.out.println("Error " + e);
}
return outty;
}
/**
* Set the log file to be off of the webapp root, and
* will do the same with the file loader paths
*
* @param config The Servlet configuration.
* @return The Properties collection of Velocity properties.
* @throws exceptions when failed to read the properties or log files
*/
protected Properties loadConfiguration(ServletConfig config)
throws IOException, FileNotFoundException
{
/*
* get our properties file and load it
*/
String propsFile = config.getInitParameter(INIT_PROPS_KEY);
Properties p = new Properties();
if ( propsFile != null )
{
String realPath = getServletContext().getRealPath(propsFile);
if ( realPath != null )
{
propsFile = realPath;
}
p.load( new FileInputStream(propsFile) );
}
/*
* first, normalize our velocity log file to be in the
* webapp
*/
String log = p.getProperty( Velocity.RUNTIME_LOG);
if (log != null )
{
log = getServletContext().getRealPath( log );
if (log != null)
{
p.setProperty( Velocity.RUNTIME_LOG, log );
}
}
/*
* now, if there is a file loader resource path, treat it the
* same way.
*/
String path = p.getProperty( Velocity.FILE_RESOURCE_LOADER_PATH );
if ( path != null)
{
path = getServletContext().getRealPath( path );
if ( path != null)
{
p.setProperty( Velocity.FILE_RESOURCE_LOADER_PATH, path );
}
}
return p;
}
//////////////////////////////////////////////////////////////////////
private String sessions(Context ctx)
{
// default Sessions screen
Collection sessions = WebPageManager.getSessions();
Collection targets = WebPageManager.getSites();
boolean online = WebPageManager.isInit();
ctx.put("sessions", sessions);
ctx.put("targets", targets);
ctx.put("online", new Boolean(online));
ctx.put("proxyError", WebPageManager.getErrorString());
ctx.put("cmd", this);
return "proxyConsole.vm";
}
//////////////////////////////////////////////////////////////////////
private String elementSessions(Context ctx, HttpServletRequest request)
{
String sid = request.getParameter("id");
if (sid == null)
{
return sessions(ctx);
}
// long id = Long.valueOf(sid).longValue();
SessionMap map = WebPageManager.getSession(sid);
if (map == null)
{
return sessions(ctx);
}
// default Sessions screen
boolean online = WebPageManager.isInit();
//Collection sessions = WebPageManager.getSessions();
//ctx.put("xxx_sessions", sessions );
ctx.put("online", new Boolean(online));
ctx.put("proxyError", WebPageManager.getErrorString());
ctx.put("cmd", this);
ctx.put("ne_sessions", map);
return "neConsole.vm";
}
//////////////////////////////////////////////////////////////////////
private String kill(Context ctx, HttpServletRequest request)
{
// default Sessions screen
boolean online = WebPageManager.isInit();
Collection sessions = WebPageManager.getSessions();
Collection elements = WebPageManager.getSites();
ctx.put("xxx_sessions", sessions);
ctx.put("elements", elements);
ctx.put("online", new Boolean(online));
ctx.put("proxyError", WebPageManager.getErrorString());
ctx.put("cmd", this);
return "proxyConsole.vm";
}
//////////////////////////////////////////////////////////////////////
private String killne(Context ctx)
{
return "proxyConsole.vm";
}
//////////////////////////////////////////////////////////////////////
private String clear(Context ctx)
{
return "proxyConsole.vm";
}
//////////////////////////////////////////////////////////////////////
private String test(Context ctx, HttpServletRequest request)
{
String id = request.getParameter("id");
if (id == null)
{
return sessions(ctx);
}
SessionMap map = WebPageManager.getSession(id);
if (map == null)
{
return sessions(ctx);
}
String ipa = request.getParameter("ipa");
if (ipa == null)
{
return sessions(ctx);
}
SiteSession session = (SiteSession)map.get(ipa);
if (session == null)
{
return sessions(ctx);
}
// default Sessions screen
boolean online = WebPageManager.isInit();
//Collection sessions = WebPageManager.getSessions();
//ctx.put("xxx_sessions", sessions );
ctx.put("online", new Boolean(online));
ctx.put("proxyError", WebPageManager.getErrorString());
ctx.put("cmd", this);
ctx.put("ne_sessions", map);
//ctx.put("element", session.;
ctx.put("nes", session);
return "testConsole.vm";
}
//////////////////////////////////////////////////////////////////////
public String getRefresh()
{
return servletPath + "?action=refresh";
}
public String getClear()
{
return servletPath + "?action=clear";
}
public String getDetails()
{
return servletPath + "?action=details";
}
public String getTest()
{
return servletPath + "?action=test";
}
public String getKill()
{
return servletPath + "?action=kill";
}
public String getKillne()
{
return servletPath + "?action=killne";
}
public String getLogon()
{
String proxy = proxyRoot;
Configuration config = Configuration.getInstance();
proxy = proxy.concat("?logon-test=true&" + config.getSID() + "=");
return proxy;
}
public String getProxyRoot()
{
return proxyRoot;
}
public String getWebapp()
{
Configuration config = Configuration.getInstance();
return config.getWebapp();
//return ProxyUtil.concatURLs(proxyRoot, config.getWebapp());
}
////////////////////////////////////////////////////////////////////
private String getProxyHost(HttpServletRequest request)
{
StringBuffer root = new StringBuffer();
String scheme = request.getScheme();
root.append(scheme);
root.append( "://");
int port = request.getServerPort();
root.append(request.getServerName());
if ( (port > 0) &&
((scheme.equals("http") && port != 80) ||
(scheme.equals("https") && port != 443)
)
)
{
root.append(":");
root.append(port);
}
root.append( Configuration.WPS_SERVLET );
return root.toString();
}
//////////////////////////////////////////////////////////////
void bootStrapProxy(HttpServletRequest request,
HttpServletResponse response)
{
ServletContext ctx = getServletContext();
try
{
RequestDispatcher dispatcher
= ctx.getRequestDispatcher(Configuration.WPS_SERVLET);
dispatcher.forward(request, response);
}
catch (Exception e)
{
}
}
}