org.apache.felix.webconsole.AbstractWebConsolePlugin Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.felix.webconsole;
import java.io.*;
import java.lang.reflect.*;
import java.net.URL;
import java.net.URLConnection;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.*;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.*;
import org.apache.commons.io.IOUtils;
import org.apache.felix.webconsole.internal.servlet.OsgiManager;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.service.log.LogService;
/**
* The Web Console can be extended by registering an OSGi service for the interface
* {@link javax.servlet.Servlet} with the service property
* felix.webconsole.label set to the label (last segment in the URL)
* of the page. The respective service is called a Web Console Plugin or a plugin
* for short.
*
* To help rendering the response the Apache Felix Web Console bundle provides two
* options. One of the options is to extend the AbstractWebConsolePlugin overwriting
* the {@link #renderContent(HttpServletRequest, HttpServletResponse)} method.
*/
public abstract class AbstractWebConsolePlugin extends HttpServlet
{
/** Pseudo class version ID to keep the IDE quite. */
private static final long serialVersionUID = 1L;
/** The name of the request attribute containing the map of FileItems from the POST request */
public static final String ATTR_FILEUPLOAD = "org.apache.felix.webconsole.fileupload"; //$NON-NLS-1$
/**
* The name of the request attribute containing a {@link java.io.File} - upload repository path used by
* {@link org.apache.commons.fileupload.disk.DiskFileItemFactory}.
*
* The Web Console plugin, that utilizes file upload capabilities of the web console SHOULD:
*
* - Obtain the file using {@link org.osgi.framework.BundleContext#getDataFile(String)}
*
- Set the file as request attribute
*
- Use {@link WebConsoleUtil#getParameter(HttpServletRequest, String)} to obtain the file(s)
*
*
* Without setting this attribute, your plugin will not work if there is a security manager enabled.
* It is guaranteed, that your plugin has permissions to read/write/delete files to the location,
* provided by the bundle context.
*/
public static final String ATTR_FILEUPLOAD_REPO = "org.apache.felix.webconsole.fileupload.repo"; //$NON-NLS-1$
/**
* Web Console Plugin typically consists of servlet and resources such as images,
* scripts or style sheets.
*
* To load resources, a Resource Provider is used. The resource provider is an object,
* that provides a method which name is specified by this constants and it is
* 'getResource'.
*
* @see #getResourceProvider()
*/
public static final String GET_RESOURCE_METHOD_NAME = "getResource"; //$NON-NLS-1$
/**
* The header fragment read from the templates/main_header.html file
*/
private static String HEADER;
/**
* The footer fragment read from the templates/main_footer.html file
*/
private static String FOOTER;
/**
* The reference to the getResource method provided by the
* {@link #getResourceProvider()}. This is null if there is
* none or before the first check if there is one.
*
* @see #getGetResourceMethod()
*/
private Method getResourceMethod;
/**
* flag indicating whether the getResource method has already been looked
* up or not. This prevens the {@link #getGetResourceMethod()} method from
* repeatedly looking up the resource method on plugins which do not have
* one.
*/
private boolean getResourceMethodChecked;
private BundleContext bundleContext;
private static BrandingPlugin brandingPlugin = DefaultBrandingPlugin.getInstance();
private static int logLevel;
//---------- HttpServlet Overwrites ----------------------------------------
/**
* Returns the title for this plugin as returned by {@link #getTitle()}
*
* @see javax.servlet.GenericServlet#getServletName()
*/
public String getServletName()
{
return getTitle();
}
/**
* This method should return category string which will be used to render
* the plugin in the navigation menu. Default implementation returns null,
* which will result in the plugin link rendered as top level menu item.
* Concrete implementations wishing to be rendered as a sub-menu item under
* a category should override this method and return a string or define
* felix.webconsole.category OSGi property. Currently only
* single level categories are supported. So, this should be a simple
* String.
*
* @return category
*/
public String getCategory()
{
return null;
}
/**
* Renders the web console page for the request. This consist of the
* following five parts called in order:
*
* - Send back a requested resource
*
- {@link #startResponse(HttpServletRequest, HttpServletResponse)}
* - {@link #renderTopNavigation(HttpServletRequest, PrintWriter)}
* - {@link #renderContent(HttpServletRequest, HttpServletResponse)}
* - {@link #endResponse(PrintWriter)}
*
*
* Note: If a resource is sent back for the request only the first
* step is executed. Otherwise the first step is a null-operation actually
* and the latter four steps are executed in order.
*
* If the {@link #isHtmlRequest(HttpServletRequest)} method returns
* false only the
* {@link #renderContent(HttpServletRequest, HttpServletResponse)} method is
* called.
*
* @see javax.servlet.http.HttpServlet#doGet(javax.servlet.http.HttpServletRequest,
* javax.servlet.http.HttpServletResponse)
*/
protected void doGet( HttpServletRequest request, HttpServletResponse response ) throws ServletException,
IOException
{
if ( !spoolResource( request, response ) )
{
// detect if this is an html request
if ( isHtmlRequest(request) )
{
// start the html response, write the header, open body and main div
PrintWriter pw = startResponse( request, response );
// render top navigation
renderTopNavigation( request, pw );
// wrap content in a separate div
pw.println( "
" ); //$NON-NLS-1$
renderContent( request, response );
pw.println( "" ); //$NON-NLS-1$
// close the main div, body, and html
endResponse( pw );
}
else
{
renderContent( request, response );
}
}
}
/**
* Detects whether this request is intended to have the headers and
* footers of this plugin be rendered or not. This method always returns
* true and may be overwritten by plugins to detect
* from the actual request, whether or not to render the header and
* footer.
*
* @param request the original request passed from the HTTP server
* @return true if the page should have headers and footers rendered
*/
protected boolean isHtmlRequest( final HttpServletRequest request )
{
return true;
}
//---------- AbstractWebConsolePlugin API ----------------------------------
/**
* This method is called from the Felix Web Console to ensure the
* AbstractWebConsolePlugin is correctly setup.
*
* It is called right after the Web Console receives notification for
* plugin registration.
*
* @param bundleContext the context of the plugin bundle
*/
public void activate( BundleContext bundleContext )
{
this.bundleContext = bundleContext;
}
/**
* This method is called, by the Web Console to de-activate the plugin and release
* all used resources.
*/
public void deactivate()
{
this.bundleContext = null;
}
/**
* This method is used to render the content of the plug-in. It is called internally
* from the Web Console.
*
* @param req the HTTP request send from the user
* @param res the HTTP response object, where to render the plugin data.
* @throws IOException if an input or output error is
* detected when the servlet handles the request
* @throws ServletException if the request for the GET
* could not be handled
*/
protected abstract void renderContent( HttpServletRequest req, HttpServletResponse res ) throws ServletException,
IOException;
/**
* Retrieves the label. This is the last component in the servlet path.
*
* This method MUST be overridden, if the {@link #AbstractWebConsolePlugin()}
* constructor is used.
*
* @return the label.
*/
public abstract String getLabel();
/**
* Retrieves the title of the plug-in. It is displayed in the page header
* and is also included in the title of the HTML document.
*
* This method MUST be overridden, if the {@link #AbstractWebConsolePlugin()}
* constructor is used.
*
* @return the plugin title.
*/
public abstract String getTitle();
/**
* Returns a list of CSS reference paths or null if no
* additional CSS files are provided by the plugin.
*
* The result is an array of strings which are used as the value of
* the href attribute of the <link> elements
* placed in the head section of the HTML generated. If the reference is
* a relative path, it is turned into an absolute path by prepending the
* value of the {@link WebConsoleConstants#ATTR_APP_ROOT} request attribute.
*
* @return The list of additional CSS files to reference in the head
* section or null if no such CSS files are required.
*/
protected String[] getCssReferences()
{
return null;
}
/**
* Returns the BundleContext with which this plugin has been
* activated. If the plugin has not be activated by calling the
* {@link #activate(BundleContext)} method, this method returns
* null.
*
* @return the bundle context or null if the bundle is not activated.
*/
protected BundleContext getBundleContext()
{
return bundleContext;
}
/**
* Returns the Bundle pertaining to the
* {@link #getBundleContext() bundle context} with which this plugin has
* been activated. If the plugin has not be activated by calling the
* {@link #activate(BundleContext)} method, this method returns
* null.
*
* @return the bundle or null if the plugin is not activated.
*/
public final Bundle getBundle()
{
final BundleContext bundleContext = getBundleContext();
return ( bundleContext != null ) ? bundleContext.getBundle() : null;
}
/**
* Returns the object which might provide resources. The class of this
* object is used to find the getResource method.
*
* This method may be overwritten by extensions. This base class
* implementation returns this instance.
*
* @return The resource provider object or null if no
* resources will be provided by this plugin.
*/
protected Object getResourceProvider()
{
return this;
}
/**
* Returns a method which is called on the
* {@link #getResourceProvider() resource provider} class to return an URL
* to a resource which may be spooled when requested. The method has the
* following signature:
*
* [modifier] URL getResource(String path);
*
* Where the [modifier] may be public, protected
* or private (if the method is declared in the class of the
* resource provider). It is suggested to use the private
* modifier if the method is declared in the resource provider class or
* the protected modifier if the method is declared in a
* base class of the resource provider.
*
* @return The getResource(String) method or null
* if the {@link #getResourceProvider() resource provider} is
* null or does not provide such a method.
*/
private final Method getGetResourceMethod()
{
// return what we know of the getResourceMethod, if we already checked
if (getResourceMethodChecked) {
return getResourceMethod;
}
Method tmpGetResourceMethod = null;
Object resourceProvider = getResourceProvider();
if ( resourceProvider != null )
{
try
{
Class cl = resourceProvider.getClass();
while ( tmpGetResourceMethod == null && cl != Object.class )
{
Method[] methods = cl.getDeclaredMethods();
for ( int i = 0; i < methods.length; i++ )
{
Method m = methods[i];
if ( GET_RESOURCE_METHOD_NAME.equals( m.getName() ) && m.getParameterTypes().length == 1
&& m.getParameterTypes()[0] == String.class && m.getReturnType() == URL.class )
{
// ensure modifier is protected or public or the private
// method is defined in the plugin class itself
int mod = m.getModifiers();
if ( Modifier.isProtected( mod ) || Modifier.isPublic( mod )
|| ( Modifier.isPrivate( mod ) && cl == resourceProvider.getClass() ) )
{
m.setAccessible( true );
tmpGetResourceMethod = m;
break;
}
}
}
cl = cl.getSuperclass();
}
}
catch ( Throwable t )
{
tmpGetResourceMethod = null;
}
}
// set what we have found and prevent future lookups
getResourceMethod = tmpGetResourceMethod;
getResourceMethodChecked = true;
// now also return the method
return getResourceMethod;
}
/**
* Calls the ServletContext.log(String) method if the
* configured log level is less than or equal to the given level.
*
* Note, that the level paramter is only used to decide whether
* the GenericServlet.log(String) method is called or not. The
* actual implementation of the GenericServlet.log method is
* outside of the control of this method.
*
* If the servlet has not been initialized yet or has already been destroyed
* the message is printed to stderr.
*
* @param level The log level at which to log the message
* @param message The message to log
*/
public void log( int level, String message )
{
if ( logLevel >= level )
{
ServletConfig config = getServletConfig();
if ( config != null )
{
ServletContext context = config.getServletContext();
if ( context != null )
{
context.log( message );
return;
}
}
System.err.println( message );
}
}
/**
* Calls the ServletContext.log(String, Throwable) method if
* the configured log level is less than or equal to the given
* level.
*
* Note, that the level paramter is only used to decide whether
* the GenericServlet.log(String, Throwable) method is called
* or not. The actual implementation of the GenericServlet.log
* method is outside of the control of this method.
*
* @param level The log level at which to log the message
* @param message The message to log
* @param t The Throwable to log with the message
*/
public void log( int level, String message, Throwable t )
{
if ( logLevel >= level )
{
ServletConfig config = getServletConfig();
if ( config != null )
{
ServletContext context = config.getServletContext();
if ( context != null )
{
context.log( message, t );
return;
}
}
System.err.println( message );
if ( t != null )
{
t.printStackTrace( System.err );
}
}
}
/**
* If the request addresses a resource which may be served by the
* getResource method of the
* {@link #getResourceProvider() resource provider}, this method serves it
* and returns true. Otherwise false is returned.
* false is also returned if the resource provider has no
* getResource method.
*
* If true is returned, the request is considered complete and
* request processing terminates. Otherwise request processing continues
* with normal plugin rendering.
*
* @param request The request object
* @param response The response object
* @return true if the request causes a resource to be sent back.
*
* @throws IOException If an error occurs accessing or spooling the resource.
*/
private final boolean spoolResource(final HttpServletRequest request,
final HttpServletResponse response) throws IOException
{
try
{
// We need to call spoolResource0 in privileged block because it uses reflection, which
// requires the following set of permissions:
// (java.lang.RuntimePermission "getClassLoader")
// (java.lang.RuntimePermission "accessDeclaredMembers")
// (java.lang.reflect.ReflectPermission "suppressAccessChecks")
// See also https://issues.apache.org/jira/browse/FELIX-4652
final Boolean ret = (Boolean) AccessController.doPrivileged(new PrivilegedExceptionAction()
{
public Object run() throws Exception
{
return spoolResource0(request, response) ? Boolean.TRUE : Boolean.FALSE;
}
});
return ret.booleanValue();
}
catch (PrivilegedActionException e)
{
final Exception x = e.getException();
throw x instanceof IOException ? (IOException) x : new IOException(
x.toString());
}
}
final boolean spoolResource0( HttpServletRequest request, HttpServletResponse response ) throws IOException
{
// no resource if no resource accessor
Method getResourceMethod = getGetResourceMethod();
if ( getResourceMethod == null )
{
return false;
}
String pi = request.getPathInfo();
InputStream ins = null;
try
{
// check for a resource, fail if none
URL url = ( URL ) getResourceMethod.invoke( getResourceProvider(), new Object[]
{ pi } );
if ( url == null )
{
return false;
}
// open the connection and the stream (we use the stream to be able
// to at least hint to close the connection because there is no
// method to explicitly close the conneciton, unfortunately)
URLConnection connection = url.openConnection();
ins = connection.getInputStream();
// FELIX-2017 Equinox may return an URL for a non-existing
// resource but then (instead of throwing) return null on
// getInputStream. We should account for this situation and
// just assume a non-existing resource in this case.
if (ins == null) {
return false;
}
// check whether we may return 304/UNMODIFIED
long lastModified = connection.getLastModified();
if ( lastModified > 0 )
{
long ifModifiedSince = request.getDateHeader( "If-Modified-Since" ); //$NON-NLS-1$
if ( ifModifiedSince >= ( lastModified / 1000 * 1000 ) )
{
// Round down to the nearest second for a proper compare
// A ifModifiedSince of -1 will always be less
response.setStatus( HttpServletResponse.SC_NOT_MODIFIED );
return true;
}
// have to send, so set the last modified header now
response.setDateHeader( "Last-Modified", lastModified ); //$NON-NLS-1$
}
// describe the contents
response.setContentType( getServletContext().getMimeType( pi ) );
response.setIntHeader( "Content-Length", connection.getContentLength() ); //$NON-NLS-1$
// spool the actual contents
OutputStream out = response.getOutputStream();
byte[] buf = new byte[2048];
int rd;
while ( ( rd = ins.read( buf ) ) >= 0 )
{
out.write( buf, 0, rd );
}
// over and out ...
return true;
}
catch ( IllegalAccessException iae )
{
// log or throw ???
}
catch ( InvocationTargetException ite )
{
// log or throw ???
// Throwable cause = ite.getTargetException();
}
finally
{
IOUtils.closeQuietly(ins);
}
return false;
}
/**
* This method is responsible for generating the top heading of the page.
*
* @param request the HTTP request coming from the user
* @param response the HTTP response, where data is rendered
* @return the writer that was used for generating the response.
* @throws IOException on I/O error
* @see #endResponse(PrintWriter)
*/
protected PrintWriter startResponse( HttpServletRequest request, HttpServletResponse response ) throws IOException
{
response.setCharacterEncoding( "utf-8" ); //$NON-NLS-1$
response.setContentType( "text/html" ); //$NON-NLS-1$
final PrintWriter pw = response.getWriter();
final String appRoot = ( String ) request.getAttribute( WebConsoleConstants.ATTR_APP_ROOT );
// support localization of the plugin title
String title = getTitle();
if ( title.startsWith( "%" ) ) //$NON-NLS-1$
{
title = "${" + title.substring( 1 ) + "}"; //$NON-NLS-1$ //$NON-NLS-2$
}
VariableResolver resolver = WebConsoleUtil.getVariableResolver(request);
if (resolver instanceof DefaultVariableResolver) {
DefaultVariableResolver r = (DefaultVariableResolver) resolver;
r.put("head.title", title); //$NON-NLS-1$
r.put("head.label", getLabel()); //$NON-NLS-1$
r.put("head.cssLinks", getCssLinks(appRoot)); //$NON-NLS-1$
r.put("brand.name", brandingPlugin.getBrandName()); //$NON-NLS-1$
r.put("brand.product.url", brandingPlugin.getProductURL()); //$NON-NLS-1$
r.put("brand.product.name", brandingPlugin.getProductName()); //$NON-NLS-1$
r.put("brand.product.img", toUrl( brandingPlugin.getProductImage(), appRoot )); //$NON-NLS-1$
r.put("brand.favicon", toUrl( brandingPlugin.getFavIcon(), appRoot )); //$NON-NLS-1$
r.put("brand.css", toUrl( brandingPlugin.getMainStyleSheet(), appRoot )); //$NON-NLS-1$
}
pw.println( getHeader() );
return pw;
}
/**
* This method is called to generate the top level links with the available plug-ins.
*
* @param request the HTTP request coming from the user
* @param pw the writer, where the HTML data is rendered
*/
protected void renderTopNavigation( HttpServletRequest request, PrintWriter pw )
{
// assume pathInfo to not be null, else this would not be called
String current = request.getPathInfo();
int slash = current.indexOf( "/", 1 ); //$NON-NLS-1$
if ( slash < 0 )
{
slash = current.length();
}
current = current.substring( 1, slash );
String appRoot = ( String ) request.getAttribute( WebConsoleConstants.ATTR_APP_ROOT );
Map menuMap = ( Map ) request.getAttribute( OsgiManager.ATTR_LABEL_MAP_CATEGORIZED );
this.renderMenu( menuMap, appRoot, pw );
// render lang-box
Map langMap = (Map) request.getAttribute(WebConsoleConstants.ATTR_LANG_MAP);
if (null != langMap && !langMap.isEmpty())
{
// determine the currently selected locale from the request and fail-back
// to the default locale if not set
// if locale is missing in locale map, the default 'en' locale is used
Locale reqLocale = request.getLocale();
String locale = null != reqLocale ? reqLocale.getLanguage()
: Locale.getDefault().getLanguage();
if (!langMap.containsKey(locale))
{
locale = Locale.getDefault().getLanguage();
}
if (!langMap.containsKey(locale))
{
locale = "en"; //$NON-NLS-1$
}
pw.println("
"); //$NON-NLS-1$
pw.println(" "); //$NON-NLS-1$
printLocaleElement(pw, appRoot, locale, langMap.get(locale));
pw.println(" "); //$NON-NLS-1$
pw.println(" "); //$NON-NLS-1$
for (Iterator li = langMap.keySet().iterator(); li.hasNext();)
{
// 
final Object l = li.next();
if (!l.equals(locale))
{
printLocaleElement(pw, appRoot, l, langMap.get(l));
}
}
pw.println(" "); //$NON-NLS-1$
pw.println(""); //$NON-NLS-1$
}
}
protected void renderMenu( Map menuMap, String appRoot, PrintWriter pw )
{
if ( menuMap != null )
{
SortedMap categoryMap = sortMenuCategoryMap( menuMap, appRoot );
pw.println( "" );
}
}
private void renderMenu( Map menuMap, String appRoot, PrintWriter pw, int level )
{
pw.println( "" );
renderSubmenu( menuMap, appRoot, pw, level );
pw.println( "
" );
}
private void renderSubmenu( Map menuMap, String appRoot, PrintWriter pw, int level )
{
String liStyleClass = " class=\"navMenuItem-" + level + "\"";
Iterator itr = menuMap.keySet().iterator();
while ( itr.hasNext() )
{
String key = ( String ) itr.next();
MenuItem menuItem = ( MenuItem ) menuMap.get( key );
pw.println( "" + menuItem.getLink() );
Map subMenu = menuItem.getSubMenu();
if ( subMenu != null )
{
renderMenu( subMenu, appRoot, pw, level + 1 );
}
pw.println( "" );
}
}
private static final void printLocaleElement( PrintWriter pw, String appRoot, Object langCode, Object langName )
{
pw.print(" !["); //$NON-NLS-1$
pw.print(langCode);
pw.print("]("); //$NON-NLS-1$
pw.print(appRoot);
pw.print("/res/flags/"); //$NON-NLS-1$
pw.print(langCode);
pw.print(".gif "\"); //$NON-NLS-1$
pw.print(langName);
pw.println(\"")
"); //$NON-NLS-1$
}
/**
* This method is responsible for generating the footer of the page.
*
* @param pw the writer, where the HTML data is rendered
* @see #startResponse(HttpServletRequest, HttpServletResponse)
*/
protected void endResponse( PrintWriter pw )
{
pw.println(getFooter());
}
/**
* An utility method, that is used to filter out simple parameter from file
* parameter when multipart transfer encoding is used.
*
* This method processes the request and sets a request attribute
* {@link #ATTR_FILEUPLOAD}. The attribute value is a {@link Map}
* where the key is a String specifying the field name and the value
* is a {@link org.apache.commons.fileupload.FileItem}.
*
* @param request the HTTP request coming from the user
* @param name the name of the parameter
* @return if not multipart transfer encoding is used - the value is the
* parameter value or null if not set. If multipart is used,
* and the specified parameter is field - then the value of the parameter
* is returned.
* @deprecated use {@link WebConsoleUtil#getParameter(HttpServletRequest, String)}
*/
public static final String getParameter( HttpServletRequest request, String name )
{
return WebConsoleUtil.getParameter(request, name);
}
/**
* Utility method to handle relative redirects.
* Some application servers like Web Sphere handle relative redirects differently
* therefore we should make an absolute URL before invoking send redirect.
*
* @param request the HTTP request coming from the user
* @param response the HTTP response, where data is rendered
* @param redirectUrl the redirect URI.
* @throws IOException If an input or output exception occurs
* @throws IllegalStateException If the response was committed or if a partial
* URL is given and cannot be converted into a valid URL
* @deprecated use {@link WebConsoleUtil#sendRedirect(HttpServletRequest, HttpServletResponse, String)}
*/
protected void sendRedirect(final HttpServletRequest request,
final HttpServletResponse response,
String redirectUrl) throws IOException {
WebConsoleUtil.sendRedirect(request, response, redirectUrl);
}
/**
* Returns the {@link BrandingPlugin} currently used for web console
* branding.
*
* @return the brandingPlugin
*/
public static BrandingPlugin getBrandingPlugin() {
return AbstractWebConsolePlugin.brandingPlugin;
}
/**
* Sets the {@link BrandingPlugin} to use globally by all extensions of
* this class for branding.
*
* Note: This method is intended to be used internally by the Web Console
* to update the branding plugin to use.
*
* @param brandingPlugin the brandingPlugin to set
*/
public static final void setBrandingPlugin(BrandingPlugin brandingPlugin) {
if(brandingPlugin == null){
AbstractWebConsolePlugin.brandingPlugin = DefaultBrandingPlugin.getInstance();
} else {
AbstractWebConsolePlugin.brandingPlugin = brandingPlugin;
}
}
/**
* Sets the log level to be applied for calls to the {@link #log(int, String)}
* and {@link #log(int, String, Throwable)} methods.
*
* Note: This method is intended to be used internally by the Web Console
* to update the log level according to the Web Console configuration.
*
* @param logLevel the maximum allowed log level. If message is logged with
* lower level it will not be forwarded to the logger.
*/
public static final void setLogLevel( int logLevel )
{
AbstractWebConsolePlugin.logLevel = logLevel;
}
private final String getHeader()
{
// MessageFormat pattern place holder
// 0 main title (brand name)
// 1 console plugin title
// 2 application root path (ATTR_APP_ROOT)
// 3 console plugin label (from the URI)
// 4 branding favourite icon (BrandingPlugin.getFavIcon())
// 5 branding main style sheet (BrandingPlugin.getMainStyleSheet())
// 6 branding product URL (BrandingPlugin.getProductURL())
// 7 branding product name (BrandingPlugin.getProductName())
// 8 branding product image (BrandingPlugin.getProductImage())
// 9 additional HTML code to be inserted into the
section
// (for example plugin provided CSS links)
if ( HEADER == null )
{
HEADER = readTemplateFile( AbstractWebConsolePlugin.class, "/templates/main_header.html" ); //$NON-NLS-1$
}
return HEADER;
}
private final String getFooter()
{
if ( FOOTER == null )
{
FOOTER = readTemplateFile( AbstractWebConsolePlugin.class, "/templates/main_footer.html" ); //$NON-NLS-1$
}
return FOOTER;
}
/**
* Reads the templateFile as a resource through the class
* loader of this class converting the binary data into a string using
* UTF-8 encoding.
*
* If the template file cannot read into a string and an exception is
* caused, the exception is logged and an empty string returned.
*
* @param templateFile The absolute path to the template file to read.
* @return The contents of the template file as a string or and empty
* string if the template file fails to be read.
*
* @throws NullPointerException if templateFile is
* null
* @throws RuntimeException if an IOException is thrown reading
* the template file into a string. The exception provides the
* exception thrown as its cause.
*/
protected final String readTemplateFile( final String templateFile ) {
return readTemplateFile( getClass(), templateFile );
}
private final String readTemplateFile( final Class clazz, final String templateFile)
{
InputStream templateStream = clazz.getResourceAsStream( templateFile );
if ( templateStream != null )
{
try
{
String str = IOUtils.toString( templateStream, "UTF-8" ); //$NON-NLS-1$
switch ( str.charAt(0) )
{ // skip BOM
case 0xFEFF: // UTF-16/UTF-32, big-endian
case 0xFFFE: // UTF-16, little-endian
case 0xEFBB: // UTF-8
return str.substring(1);
}
return str;
}
catch ( IOException e )
{
// don't use new Exception(message, cause) because cause is 1.4+
throw new RuntimeException( "readTemplateFile: Error loading " + templateFile + ": " + e ); //$NON-NLS-1$ //$NON-NLS-2$
}
finally
{
IOUtils.closeQuietly( templateStream );
}
}
// template file does not exist, return an empty string
log( LogService.LOG_ERROR, "readTemplateFile: File '" + templateFile + "' not found through class " + clazz ); //$NON-NLS-1$ //$NON-NLS-2$
return ""; //$NON-NLS-1$
}
private final String getCssLinks( final String appRoot )
{
// get the CSS references and return nothing if there are none
final String[] cssRefs = getCssReferences();
if ( cssRefs == null )
{
return ""; //$NON-NLS-1$
}
// build the CSS links from the references
final StringBuffer buf = new StringBuffer();
for ( int i = 0; i < cssRefs.length; i++ )
{
buf.append( "" ); //$NON-NLS-1$
}
return buf.toString();
}
/**
* If the url starts with a slash, it is considered an absolute
* path (relative URL) which must be prefixed with the Web Console
* application root path. Otherwise the url is assumed to
* either be a relative path or an absolute URL, both must not be prefixed.
*
* @param url The url path to optionally prefix with the application root
* path
* @param appRoot The application root path to optionally put in front of
* the url.
* @throws NullPointerException if url is null.
*/
private static final String toUrl( final String url, final String appRoot )
{
if ( url.startsWith( "/" ) ) //$NON-NLS-1$
{
return appRoot + url;
}
return url;
}
private SortedMap sortMenuCategoryMap( Map map, String appRoot )
{
SortedMap sortedMap = new TreeMap( String.CASE_INSENSITIVE_ORDER );
Iterator keys = map.keySet().iterator();
while ( keys.hasNext() )
{
String key = ( String ) keys.next();
if ( key.startsWith( "category." ) )
{
SortedMap categoryMap = sortMenuCategoryMap( ( Map ) map.get( key ), appRoot );
String title = key.substring( key.indexOf( '.' ) + 1 );
if ( sortedMap.containsKey( title ) )
{
( ( MenuItem ) sortedMap.get( title ) ).setSubMenu( categoryMap );
}
else
{
String link = "" + title + "";
MenuItem menuItem = new MenuItem( link, categoryMap );
sortedMap.put( title, menuItem );
}
}
else
{
String title = ( String ) map.get( key );
String link = "" + title + "";
if ( sortedMap.containsKey( title ) )
{
( ( MenuItem ) sortedMap.get( title ) ).setLink( link );
}
else
{
MenuItem menuItem = new MenuItem( link );
sortedMap.put( title, menuItem );
}
}
}
return sortedMap;
}
private static class MenuItem
{
private String link;
private Map subMenu;
public MenuItem( String link )
{
this.link = link;
}
public MenuItem( String link, Map subMenu )
{
super();
this.link = link;
this.subMenu = subMenu;
}
public String getLink()
{
return link;
}
public void setLink( String link )
{
this.link = link;
}
public Map getSubMenu()
{
return subMenu;
}
public void setSubMenu( Map subMenu )
{
this.subMenu = subMenu;
}
}
}