PageConfig.java revision 50203181d8c071cfd69cb197b5da0eda5c4d6372
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* See LICENSE.txt included in this distribution for the specific
* language governing permissions and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at LICENSE.txt.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2011 Jens Elkner.
*/
/**
* A simple container to lazy initialize common vars wrt. a single request.
* It MUST NOT be shared between several requests and {@link #cleanup()} should
* be called before the page context gets destroyed (e.g. by overwriting
* {@code jspDestroy()} or when leaving the {@code service} method.
* <p>
* Purpose is to decouple implementation details from web design, so that the
* JSP developer does not need to know every implementation detail and normally
* this class a bean with request scope ;-)). Furthermore it helps to keep the
* pages (how content gets generated) consistent and to document the request
* parameters used.
* <p>
* General contract for this class (i.e. if not explicitly documented):
* no method of this class changes neither the request nor the response.
*
* @author Jens Elkner
* @version $Revision$
*/
public class PageConfig {
// TODO if still used, get it from the app context
boolean check4on = true;
private RuntimeEnvironment env;
private IgnoredNames ignoredNames;
private File resourceFile;
private String resourcePath;
private EftarFileReader eftarReader;
private String sourceRootPath;
private String uriEncodedPath;
private Boolean hasAnnotation;
private Annotation annotation;
private Boolean hasHistory;
private String requestedProjectsString;
private String[] dirFileList;
private QueryBuilder queryBuilder;
private StringBuilder headLines;
/**
* Add the given data to the <head> section of the html page to
* generate.
* @param data data to add. It is copied as is, so remember to escape
* special characters ...
*/
return;
}
headLines = new StringBuilder();
}
}
/**
* Get addition data, which should be added as is to the <head>
* section of the html page.
* @return an empty string if nothing to add, the data otherwise.
*/
public String getHeaderData() {
}
/**
* Get all data required to create a diff view wrt. to this request in one go.
* @return an instance with just enough information to render a sufficient
* view. If not all required parameters were given either they are
* supplemented with reasonable defaults if possible, otherwise the
* related field(s) are {@code null}. {@link DiffData#errorMsg}
* {@code != null} indicates, that an error occured and one should not
* try to render a view.
*/
public DiffData getDiffData() {
for (int i = 1; i <= 2; i++) {
if (p != null) {
}
}
}
+ getUriEncodedPath() + "\">history</a>";
return data;
}
return data; // no more info needed
}
try {
for (int i = 0; i < 2; i++) {
}
try {
} catch (IOException e) {
}
return data;
}
}
Project p = getProject();
for (int i = 0; i < 2; i++) {
}
}
} catch (Exception e) {
} finally {
try {
} catch (Exception e) {
/** ignore */
}
}
for (int i = 0; i < 2; i++) {
try {
} catch (Exception e) {
/** ignore */
}
}
}
}
return data;
}
try {
} catch (DifferentiationFailedException e) {
}
for (int i = 0; i < 2; i++) {
try {
} catch (URISyntaxException e) {
// should not happen
}
}
}
return data;
}
/**
* Get the diff display type to use wrt. the request parameter {@code format}.
* @return {@link DiffType#SIDEBYSIDE} if the request contains no such parameter
* or one with an unknown value, the recognized diff type otherwise.
* @see DiffType#get(String)
* @see DiffType#getAbbrev()
* @see DiffType#toString()
*/
public DiffType getDiffType() {
}
/**
* Check, whether a full diff should be displayed.
* @return {@code true} if a request parameter {@code full} with the
* literal value {@code 1} was found.
*/
public boolean fullDiff() {
}
/**
* Check, whether the request contains minial information required to
* produce a valid page. If this method returns an empty string, the
* referred file or directory actually exists below the source root
* directory and is readable.
*
* @return {@code null} if the referred src file, directory or history is not
* available, an empty String if further processing is ok and a none-empty
* string which contains the URI encoded redirect path if the request
* should be redirected.
* @see #resourceNotAvailable()
* @see #getOnRedirect()
* @see #getDirectoryRedirect()
*/
public String canProcess() {
if (resourceNotAvailable()) {
return getOnRedirect();
}
return null;
}
// jel: outfactored from list.jsp - seems to be bogus
if (isDir()) {
return null;
}
}
return null;
}
}
}
/**
* Get a list of filenames in the requested path.
* @return an empty array, if the resource does not exist, is not a
* directory or an error occured when reading it, otherwise a list of
* filenames in that directory.
* @see #getResourceFile()
* @see #isDir()
*/
public String[] getResourceFileList() {
if (dirFileList == null) {
}
if (dirFileList == null) {
}
}
return dirFileList;
}
/**
* Get the time of last modification of the related file or directory.
* @return the last modification time of the related file or directory.
* @see File#lastModified()
*/
public long getLastModified() {
return getResourceFile().lastModified();
}
/**
* Get all RSS related directories from the request using its {@code also}
* parameter.
* @return an empty string if the requested resource is not a directory, a
* space (' ') separated list of unchecked directory names otherwise.
*/
public String getHistoryDirs() {
if (!isDir()) {
return "";
}
return path;
}
}
}
/**
* Get the int value of the given request parameter.
* @param name name of the parameter to lookup.
* @param defaultValue value to return, if the parameter is not set, is not
* a number, or is < 0.
* @return the parsed int value on success, the given default value otherwise.
*/
try {
if (x >= 0) {
defaultValue = x;
}
} catch (Exception e) {
// fallback to default
}
}
return defaultValue;
}
/**
* Get the <b>start</b> index for a search result to return by looking up
* the {@code start} request parameter.
* @return 0 if the corresponding start parameter is not set or not a number,
* the number found otherwise.
*/
public int getSearchStart() {
}
/**
* Get the number of search results to max. return by looking up the
* {@code n} request parameter.
*
* @return the default number of hits if the corresponding start parameter
* is not set or not a number, the number found otherwise.
*/
public int getSearchMaxItems() {
}
/**
* Get sort orders from the request parameter {@code sort} and if this list
* would be empty from the cookie {@code OpenGrokorting}.
* @return a possible empty list which contains the sort order values in
* the same order supplied by the request parameter or cookie(s).
*/
}
}
}
}
}
return sort;
}
/**
* Get a reference to the {@code QueryBuilder} wrt. to the current request
* parameters:
* <dl>
* <dt>q</dt>
* <dd>freetext lookup rules</dd>
* <dt>defs</dt>
* <dd>definitions lookup rules</dd>
* <dt>path</dt>
* <dd>path related rules</dd>
* <dt>hist</dt>
* <dd>history related rules</dd>
* </dl>
* @return a query builder with all relevant fields populated.
*/
public QueryBuilder getQueryBuilder() {
if (queryBuilder == null) {
queryBuilder = new QueryBuilder().setFreetext(req.getParameter("q")).setDefs(req.getParameter("defs")).setRefs(req.getParameter("refs")).setPath(req.getParameter("path")).setHist(req.getParameter("hist"));
// This is for backward compatibility with links created by OpenGrok
// 0.8.x and earlier. We used to concatenate the entire query into a
// single string and send it in the t parameter. If we get such a
// link, just add it to the freetext field, and we'll get the old
// behaviour. We can probably remove this code in the first feature
// release after 0.9.
if (t != null) {
}
}
return queryBuilder;
}
/**
* Get the eftar reader for the opengrok data directory. If it has been
* already opened and not closed, this instance gets returned. One should
* not close it once used: {@link #cleanup()} takes care to close it.
*
* @return {@code null} if a reader can't be established, the reader
* otherwise.
*/
public EftarFileReader getEftarReader() {
try {
+ "/index/dtags.eftar");
} catch (Exception e) {
/* ignore */
}
}
return eftarReader;
}
/**
* Get the definition tag for the request related file or directory.
* @return an empty string if not found, the tag otherwise.
*/
public String getDefineTagsIndex() {
return dtag;
}
if (eftarReader != null) {
try {
// cfg.getPrefix() != Prefix.XREF_S) {
} catch (IOException e) {
/* ignore */
}
}
dtag = "";
}
return dtag;
}
/**
* Get the revision parameter {@code r} from the request.
* @return {@code "r=<i>revision</i>"} if found, an empty string otherwise.
*/
public String getRequestedRevision() {
}
return rev;
}
/**
* Check, whether the request related resource has history information.
* @return {@code true} if history is available.
* @see HistoryGuru#hasHistory(File)
*/
public boolean hasHistory() {
if (hasHistory == null) {
}
return hasHistory.booleanValue();
}
/**
* Check, whether annotations are available for the related resource.
* @return {@code true} if annotions are available.
*/
public boolean hasAnnotations() {
if (hasAnnotation == null) {
}
return hasAnnotation.booleanValue();
}
/**
* Check, whether the resource to show should be annotated.
* @return {@code true} if annotation is desired and available.
*/
public boolean annotate() {
}
return annotate.booleanValue();
}
/**
* Get the annotation for the reqested resource.
* @return {@code null} if not available or annotation was not requested,
* the cached annotation otherwise.
*/
public Annotation getAnnotation() {
return null;
}
if (annotation != null) {
return annotation;
}
try {
annotation = HistoryGuru.getInstance().annotate(resourceFile, rev.isEmpty() ? null : rev.substring(2));
} catch (IOException e) {
/* ignore */
}
return annotation;
}
/**
* Get the name which should be show as "Crossfile"
* @return the name of the related file or directory.
*/
public String getCrossFilename() {
return getResourceFile().getName();
}
/**
* Get the {@code path} parameter and display value for "Search only in"
* option.
* @return always an array of 3 fields, whereby field[0] contains the
* path value to use (starts and ends always with a '/'). Field[1] the
* contains string to show in the UI. field[2] is set to
* {@code disabled=""} if the current path is the "/" directory,
* otherwise set to an empty string.
*/
public String[] getSearchOnlyIn() {
if (isDir()) {
}
return res;
}
/**
* Get the project {@link #getPath()} refers to.
* @return {@code null} if not available, the project otherwise.
*/
public Project getProject() {
}
/**
* Same as {@link #getRequestedProjects()} but returns the project names as
* a coma separated String.
* @return a possible empty String but never {@code null}.
*/
public String getRequestedProjectsAsString() {
if (requestedProjectsString == null) {
requestedProjectsString = "";
} else {
}
}
}
return requestedProjectsString;
}
/**
* Get the document hash provided by the request parameter {@code h}.
* @return {@code null} if the request does not contain such a parameter,
* its value otherwise.
*/
public String getDocumentHash() {
}
/**
* Get a reference to a set of requested projects via request parameter
* {@code project} or cookies or defaults.
* <p>
* NOTE: This method assumes, that project names do <b>not</b> contain
* a comma (','), since this character is used as name separator!
*
* @return a possible empty set of project names aka descriptions but never
* {@code null}. It is determined as
* follows:
* <ol>
* <li>If there is no project in the runtime environment (RTE) an empty
* set is returned. Otherwise:</li>
* <li>If there is only one project in the RTE, this one gets returned (no
* matter, what the request actually says). Otherwise</li>
* <li>If the request parameter {@code project} contains any available
* project, the set with invalid projects removed gets returned.
* Otherwise:</li>
* <li>If the request has a cookie with the name {@code OpenGrokProject}
* and it contains any available project, the set with invalid
* projects removed gets returned. Otherwise:</li>
* <li>If a default project is set in the RTE, this project gets returned.
* Otherwise:</li>
* <li>an empty set</li>
* </ol>
*/
if (requestedProjects == null) {
}
return requestedProjects;
}
return;
}
for (int k = 0; k < p.length; k++) {
if (p[k].length() != 0) {
}
}
}
/**
* Get the cookie values for the given name. Splits comma separated values
* automatically into a list of Strings.
* @param cookieName name of the cookie.
* @return a possible empty list.
*/
}
}
}
return res;
}
/**
* Get the parameter values for the given name. Splits comma separated
* values automatically into a list of Strings.
* @param name name of the parameter.
* @return a possible empty list.
*/
}
}
return res;
}
/**
* Same as {@link #getRequestedProjects()}, but with a variable cookieName
* and parameter name. This way it is trivial to implement a project filter
* ...
* @param paramName the name of the request parameter, which possibly
* contains the project list in question.
* @param cookieName name of the cookie which possible contains project
* lists used as fallback
* @return a possible empty set but never {@code null}.
*/
String cookieName) {
return set;
}
return set;
}
}
}
}
}
}
if (defaultProject != null) {
}
}
return set;
}
/**
* Set the page title to use.
* @param title title to set (might be {@code null}).
*/
}
/**
* Get the page title to use.
* @return {@code null} if not set, the page title otherwise.
*/
return pageTitle;
}
/**
* Get the base path to use to refer to CSS stylesheets and related
* resources. Usually used to create links.
*
* @return the appropriate application directory prefixed with the
* @see HttpServletRequest#getContextPath()
* @see RuntimeEnvironment#getWebappLAF()
*/
}
/**
* Get the current runtime environment.
*
* @return the runtime env.
* @see RuntimeEnvironment#getInstance()
* @see RuntimeEnvironment#register()
*/
public RuntimeEnvironment getEnv() {
}
return env;
}
/**
* Get the name patterns used to determine, whether a file should be
* ignored.
*
* @return the corresponding value from the current runtime config..
*/
public IgnoredNames getIgnoredNames() {
if (ignoredNames == null) {
}
return ignoredNames;
}
/**
* Get the canonical path to root of the source tree. File separators are
* replaced with a '/'.
*
* @return The on disk source root directory.
* @see RuntimeEnvironment#getSourceRootPath()
*/
public String getSourceRootPath() {
if (sourceRootPath == null) {
: getEnv().getSourceRootPath();
}
return sourceRootPath;
}
/**
* Get the prefix for the related request.
* @return {@link Prefix#UNKNOWN} if the servlet path matches any known
* prefix, the prefix otherwise.
*/
}
return prefix;
}
/**
* Get the canonical path of the related resource relative to the
* source root directory (used file separators are all '/'). No check is
* made, whether the obtained path is really an accessable resource on disk.
*
* @see HttpServletRequest#getPathInfo()
* @return a possible empty String (denotes the source root directory) but
* not {@code null}.
*/
path = "";
}
}
return path;
}
/**
* If a requested resource is not available, append "/on/" to
* the source root directory and try again to resolve it.
*
* @return on success a none-{@code null} gets returned, which should be
* used to redirect the client to the propper path.
*/
public String getOnRedirect() {
if (check4on) {
}
}
return null;
}
/**
* Get the on disk file to the request related file or directory.
*
* NOTE: If a repository contains hard or symbolic links, the returned
* file may finally point to a file outside of the source root directory.
*
* @return {@code new File("/")} if the related file or directory is not
* available (can not be find below the source root directory),
* the readable file or directory otherwise.
* @see #getSourceRootPath()
* @see #getPath()
*/
public File getResourceFile() {
if (resourceFile == null) {
if (!resourceFile.canRead()) {
}
}
return resourceFile;
}
/**
* Get the canonical on disk path to the request related file or directory
* with all file separators replaced by a '/'.
*
* @return "/" if the evaluated path is invalid or outside the source root
* directory), otherwise the path to the readable file or directory.
* @see #getResourceFile()
*/
public String getResourcePath() {
if (resourcePath == null) {
? getResourceFile().getPath()
}
return resourceFile.getPath();
}
/**
* Check, whether the related request resource matches a valid file or
* directory below the source root directory and wether it matches an
* ignored pattern.
*
* @return {@code true} if the related resource does not exists or should be
* ignored.
* @see #getIgnoredNames()
* @see #getResourcePath()
*/
public boolean resourceNotAvailable() {
}
/**
* Check, whether the request related path represents a directory.
*
* @return {@code true} if directory related request
*/
public boolean isDir() {
}
return isDir.booleanValue();
}
? "/"
: "";
}
if (compressed) {
return f;
}
}
return f;
}
return null;
}
/**
* Find the files with the given names in the {@link #getPath()} directory
* relative to the crossfile directory of the opengrok data directory. It
* is tried to find the compressed file first by appending the file extension
* ".gz" to the filename. If that fails or an uncompressed version of the
* file is younger than its compressed version, the uncompressed file gets
* used.
*
* @param filenames filenames to lookup.
* @return an empty array if the related directory does not exist or the
* given list is {@code null} or empty, otherwise an array, which may
* contain {@code null} entries (when the related file could not be found)
* having the same order as the given list.
*/
return new File[0];
}
}
}
return res;
}
/**
* Lookup the file {@link #getPath()} relative to the crossfile directory
* of the opengrok data directory. It is tried to find the compressed file
* first by appending the file extension ".gz" to the filename. If that
* fails or an uncompressed version of the file is younger than its
* compressed version, the uncompressed file gets used.
* @return {@code null} if not found, the file otherwise.
*/
public File findDataFile() {
}
/**
* Get the path the request should be redirected (if any).
*
* @return {@code null} if there is no reason to redirect, the URI encoded
* redirect path to use otherwise.
*/
public String getDirectoryRedirect() {
if (isDir()) {
// => /
return null;
}
getPrefix();
//if it is an existing dir perhaps people wanted dir xref
}
}
}
return null;
}
/**
* Get the URI encoded canonical path to the related file or directory
* (the URI part between the servlet path and the start of the query string).
* @return an URI encoded path which might be an empty string but not
* {@code null}.
* @see #getPath()
*/
public String getUriEncodedPath() {
if (uriEncodedPath == null) {
}
return uriEncodedPath;
}
/**
* Get opengrok's configured dataroot directory.
* It is veriefied, that the used environment has a valid opengrok data root
* set and that it is an accessable directory.
* @return the opengrok data directory.
* @throws InvalidParameterException if inaccessable or not set.
*/
public File getDataRoot() {
throw new InvalidParameterException("dataRoot parameter is not "
+ "set in configuration.xml!");
}
throw new InvalidParameterException("The configured dataRoot '"
+ tmp
+ "' refers to a none-exsting or unreadable directory!");
}
}
return dataRoot;
}
/**
* Prepare a search helper with all required information, ready to execute
* the query implied by the related request parameters and cookies.
* <p>
* NOTE: One should check the {@link SearchHelper#errorMsg} as well as
* {@link SearchHelper#redirect} and take the appropriate action before
* executing the prepared query or continue processing.
* <p>
* This method stops populating fields as soon as an error occurs.
*
* @return a search helper.
*/
public SearchHelper prepareSearch() {
return sh;
}
// Entry page show the map
return sh;
}
// jel: this should be IMHO a config param since not only core dependend
return sh;
}
/**
* Get the config wrt. the given request. If there is none yet, a new config
* gets created, attached to the request and returned.
* <p>
*
* @param request the request to use to initialize the config parameters.
* @return always the same none-{@code null} config for a given request.
* @throws NullPointerException
* if the given parameter is {@code null}.
*/
return (PageConfig) cfg;
}
return pcfg;
}
private HttpServletRequest req;
}
/**
* Cleanup all allocated resources. Should always be called right before
* leaving the _jspService / service.
*/
public void cleanup() {
}
if (eftarReader != null) {
try {
eftarReader.close();
} catch (Exception e) {
/** ignore */
}
}
}
}