Configuration.java revision 983523cf73bc85cce6282cb5aa78b60f6bcd959f
/*
* 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
*/
/*
*/
/**
* Placeholder class for all configuration variables. Due to the multithreaded
* nature of the web application, each thread will use the same instance of the
* configuration object for each page request. Class and methods should have
* package scope, but that didn't work with the XMLDecoder/XMLEncoder.
*/
public final class Configuration {
/**
* Should the history log be cached?
*/
private boolean historyCache;
/**
* The maximum time in milliseconds {@code HistoryCache.get()} can take
* before its result is cached.
*/
private int historyCacheTime;
/**
* Should the history cache be stored in a database?
*/
private boolean historyCacheInDB;
private String sourceRoot;
private boolean generateHtml;
/**
* Default project will be used, when no project is selected and no project
* is in cookie, so basically only the first time you open the first page,
* or when you clear your web cookies
*/
private Project defaultProject;
/**
* Default size of memory to be used for flushing of lucene docs
* per thread.
* Lucene 4.x uses 16MB and 8 threads, so below is a nice tunable.
*/
private double ramBufferSize;
private boolean verbose;
/**
* If below is set, then we count how many files per project we need
* to process and print percentage of completion per project.
*/
private boolean printProgress;
private boolean allowLeadingWildcard;
private IgnoredNames ignoredNames;
private Filter includedNames;
private String userPageSuffix;
private String bugPattern;
private String reviewPage;
private String reviewPattern;
private boolean remoteScmSupported;
private boolean optimizeDatabase;
private boolean useLuceneLocking;
private boolean compressXref;
private boolean indexVersionedFilesOnly;
private boolean tagsEnabled;
private int hitsPerPage;
private int cachePages;
private String databaseDriver;
private String databaseUrl;
private String CTagsExtraOptionsFile;
private int scanningDepth;
private boolean obfuscatingEMailAddresses;
private boolean chattyStatusPage;
private int tabSize;
private int command_timeout;
public static final double defaultRamBufferSize=16;
public static final int defaultScanningDepth=3;
/**
* Get the default tab size (number of space characters per tab character)
*
*
*
*
* @return current tab size set.
* @see Project#getTabSize()
* @see org.opensolaris.opengrok.analysis.ExpandTabsReader
*/
public int getTabSize() {
return tabSize;
}
/**
* Set the default tab size (number of space characters per tab character)
*
*
*
*
* @param tabSize tabsize to set.
* @see Project#setTabSize(int)
* @see org.opensolaris.opengrok.analysis.ExpandTabsReader
*/
public void setTabSize(int tabSize) {
}
public int getScanningDepth() {
return scanningDepth;
}
public void setScanningDepth(int scanningDepth) {
this.scanningDepth = scanningDepth;
}
public int getCommandTimeout() {
return command_timeout;
}
public void setCommandTimeout(int timeout) {
this.command_timeout = timeout;
}
/**
* Creates a new instance of Configuration
*/
public Configuration() {
//defaults for an opengrok instance configuration
setHistoryCache(true);
setHistoryCacheTime(30);
setHistoryCacheInDB(false);
setUrlPrefix("/source/s?");
//setUrlPrefix("../s?"); // TODO generate relative search paths, get rid of -w <webapp> option to indexer !
//below can cause an outofmemory error, since it is defaulting to NO LIMIT
setVerbose(false);
setPrintProgress(false);
setGenerateHtml(true);
setQuickContextScan(true);
setIgnoredNames(new IgnoredNames());
setIncludedNames(new Filter());
setBugPattern("\\b([12456789][0-9]{6})\\b");
setWebappLAF("default");
setRemoteScmSupported(false);
setOptimizeDatabase(true);
setUsingLuceneLocking(false);
setCompressXref(true);
setIndexVersionedFilesOnly(false);
setTagsEnabled(false);
setHitsPerPage(25);
setCachePages(5);
//setTabSize(4);
}
}
return null;
}
}
}
}
}
return ctags;
}
}
public int getCachePages() {
return cachePages;
}
public void setCachePages(int cachePages) {
this.cachePages = cachePages;
}
public int getHitsPerPage() {
return hitsPerPage;
}
public void setHitsPerPage(int hitsPerPage) {
this.hitsPerPage = hitsPerPage;
}
/**
* Should the history log be cached?
*
* @return {@code true} if a {@code HistoryCache} implementation should be
* used, {@code false} otherwise
*/
public boolean isHistoryCache() {
return historyCache;
}
/**
* Set whether history should be cached.
*
* @param historyCache if {@code true} enable history cache
*/
public void setHistoryCache(boolean historyCache) {
this.historyCache = historyCache;
}
/**
* How long can a history request take before it's cached? If the time is
* exceeded, the result is cached. This setting only affects
* {@code FileHistoryCache}.
*
* @return the maximum time in milliseconds a history request can take
* before it's cached
*/
public int getHistoryCacheTime() {
return historyCacheTime;
}
/**
* Set the maximum time a history request can take before it's cached. This
* setting is only respected if {@code FileHistoryCache} is used.
*
* @param historyCacheTime maximum time in milliseconds
*/
public void setHistoryCacheTime(int historyCacheTime) {
this.historyCacheTime = historyCacheTime;
}
/**
* Should the history cache be stored in a database? If yes,
* {@code JDBCHistoryCache} will be used to cache the history; otherwise,
* {@code FileHistoryCache} is used.
*
* @return whether the history cache should be stored in a database
*/
public boolean isHistoryCacheInDB() {
return historyCacheInDB;
}
/**
* Set whether the history cache should be stored in a database, and
* {@code JDBCHistoryCache} should be used instead of {@code
* FileHistoryCache}.
*
* @param historyCacheInDB whether the history cached should be stored in a
* database
*/
public void setHistoryCacheInDB(boolean historyCacheInDB) {
this.historyCacheInDB = historyCacheInDB;
}
return projects;
}
}
public String getSourceRoot() {
return sourceRoot;
}
this.sourceRoot = sourceRoot;
}
public String getDataRoot() {
return dataRoot;
}
}
return repositories;
}
this.repositories = repositories;
}
public String getUrlPrefix() {
return urlPrefix;
}
/**
* Set the URL prefix to be used by the {@link
* org.opensolaris.opengrok.analysis.executables.JavaClassAnalyzer} as well
* as lexers (see {@link org.opensolaris.opengrok.analysis.JFlexXref}) when
* they create output with html links.
*
* @param urlPrefix prefix to use.
*/
}
public void setGenerateHtml(boolean generateHtml) {
this.generateHtml = generateHtml;
}
public boolean isGenerateHtml() {
return generateHtml;
}
this.defaultProject = defaultProject;
}
public Project getDefaultProject() {
return defaultProject;
}
public double getRamBufferSize() {
return ramBufferSize;
}
/**
* set size of memory to be used for flushing docs (default 16 MB)
* (this can improve index speed a LOT)
* note that this is per thread (lucene uses 8 threads by default in 4.x)
* @param ramBufferSize new size in MB
*/
public void setRamBufferSize(double ramBufferSize) {
this.ramBufferSize = ramBufferSize;
}
public boolean isVerbose() {
return verbose;
}
public void setVerbose(boolean verbose) {
}
public boolean isPrintProgress() {
return printProgress;
}
public void setPrintProgress(boolean printProgress) {
this.printProgress = printProgress;
}
public void setAllowLeadingWildcard(boolean allowLeadingWildcard) {
}
public boolean isAllowLeadingWildcard() {
return allowLeadingWildcard;
}
private boolean quickContextScan;
public boolean isQuickContextScan() {
return quickContextScan;
}
public void setQuickContextScan(boolean quickContextScan) {
this.quickContextScan = quickContextScan;
}
this.ignoredNames = ignoredNames;
}
public IgnoredNames getIgnoredNames() {
return ignoredNames;
}
this.includedNames = includedNames;
}
public Filter getIncludedNames() {
return includedNames;
}
}
public String getUserPage() {
return userPage;
}
this.userPageSuffix = userPageSuffix;
}
public String getUserPageSuffix() {
return userPageSuffix;
}
}
public String getBugPage() {
return bugPage;
}
this.bugPattern = bugPattern;
}
public String getBugPattern() {
return bugPattern;
}
public String getReviewPage() {
return reviewPage;
}
this.reviewPage = reviewPage;
}
public String getReviewPattern() {
return reviewPattern;
}
this.reviewPattern = reviewPattern;
}
public String getWebappLAF() {
return webappLAF;
}
}
public boolean isRemoteScmSupported() {
return remoteScmSupported;
}
public void setRemoteScmSupported(boolean remoteScmSupported) {
this.remoteScmSupported = remoteScmSupported;
}
public boolean isOptimizeDatabase() {
return optimizeDatabase;
}
public void setOptimizeDatabase(boolean optimizeDatabase) {
this.optimizeDatabase = optimizeDatabase;
}
public boolean isUsingLuceneLocking() {
return useLuceneLocking;
}
public void setUsingLuceneLocking(boolean useLuceneLocking) {
this.useLuceneLocking = useLuceneLocking;
}
public void setCompressXref(boolean compressXref) {
this.compressXref = compressXref;
}
public boolean isCompressXref() {
return compressXref;
}
public boolean isIndexVersionedFilesOnly() {
return indexVersionedFilesOnly;
}
public void setIndexVersionedFilesOnly(boolean indexVersionedFilesOnly) {
}
public boolean isTagsEnabled() {
return this.tagsEnabled;
}
public void setTagsEnabled(boolean tagsEnabled) {
this.tagsEnabled = tagsEnabled;
}
private transient Date lastModified;
/**
* Get the date of the last index update.
*
* @return the time of the last index update.
*/
public Date getDateForLastIndexRun() {
if (lastModified == null) {
}
return lastModified;
}
/**
* Get the contents of a file or empty string if the file cannot be read.
*/
return "";
}
try {
}
/*
* should usually not happen
*/
} finally {
try {
} catch (Exception e) { /*
* nothing we can do about it
*/ }
try {
} catch (Exception e) { /*
* nothing we can do about it
*/ }
}
}
return "";
}
/**
* The name of the file relative to the <var>DATA_ROOT</var>, which should
* be included into the footer of generated web pages.
*/
/**
* Get the contents of the footer include file.
*
* @return an empty string if it could not be read successfully, the
* contents of the file otherwise.
*/
public String getFooterIncludeFileContent() {
}
return footer;
}
/**
* The name of the file relative to the <var>DATA_ROOT</var>, which should
* be included into the footer of generated web pages.
*/
/**
* Get the contents of the footer include file.
*
* @return an empty string if it could not be read successfully, the
* contents of the file otherwise.
*/
public String getHeaderIncludeFileContent() {
}
return header;
}
/**
* The name of the eftar file relative to the <var>DATA_ROOT</var>, which
* contains definition tags.
*/
/**
* Get the eftar file, which contains definition tags.
*
* @return {@code null} if there is no such file, the file otherwise.
*/
public File getDtagsEftar() {
if (dtagsEftar == null) {
dtagsEftar = tmp;
}
}
return dtagsEftar;
}
public String getDatabaseDriver() {
return databaseDriver;
}
this.databaseDriver = databaseDriver;
}
public String getDatabaseUrl() {
return databaseUrl;
}
this.databaseUrl = databaseUrl;
}
public String getCTagsExtraOptionsFile() {
return CTagsExtraOptionsFile;
}
this.CTagsExtraOptionsFile = filename;
}
return allowedSymlinks;
}
this.allowedSymlinks = allowedSymlinks;
}
public boolean isObfuscatingEMailAddresses() {
return obfuscatingEMailAddresses;
}
public void setObfuscatingEMailAddresses(boolean obfuscate) {
this.obfuscatingEMailAddresses = obfuscate;
}
public boolean isChattyStatusPage() {
return chattyStatusPage;
}
public void setChattyStatusPage(boolean chattyStatusPage) {
this.chattyStatusPage = chattyStatusPage;
}
/**
* Write the current configuration to a file
*
* @param file the file to write the configuration into
* @throws IOException if an error occurs
*/
this.encodeObject(out);
}
}
public String getXMLRepresentationAsString() {
this.encodeObject(bos);
}
e.writeObject(this);
}
}
return decodeObject(in);
}
}
final Configuration ret;
return ret;
}
ret = d.readObject();
}
if (!(ret instanceof Configuration)) {
throw new IOException("Not a valid config file");
}
return (Configuration) ret;
}
}