Java tutorial
/* * This library is part of OpenCms - * the Open Source Content Management System * * Copyright (c) Alkacon Software GmbH (http://www.alkacon.com) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com * * For further information about OpenCms, please see the * project website: http://www.opencms.org * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package org.opencms.util; import org.opencms.i18n.CmsEncoder; import org.opencms.main.CmsIllegalArgumentException; import org.opencms.main.CmsLog; import org.opencms.main.CmsRuntimeException; import org.opencms.main.OpenCms; import java.io.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; import java.io.LineNumberReader; import java.io.OutputStreamWriter; import java.nio.charset.Charset; import java.nio.charset.IllegalCharsetNameException; import java.nio.charset.UnsupportedCharsetException; import java.util.HashMap; import java.util.Map; import java.util.Stack; import org.apache.commons.logging.Log; /** * The representation of a RFS file along with the settings to provide * access to certain portions (amount of lines) of it. <p> * * Most often the underlying file will be the OpenCms logfile. <p> * * The portion of the file that is shown is defined by a "window" of "windowSize" lines of text * at a position "windowPosition" which is an enumeration of windows in ascending order. <p> * * @since 6.0.0 */ public class CmsRfsFileViewer implements Cloneable { /** The log object for this class. */ protected static final Log LOG = CmsLog.getLog(CmsRfsFileViewer.class); /** Decides whether the view onto the underlying file via readFilePortion is enabled. */ private boolean m_enabled; /** The character encoding of the underlying file. */ private Charset m_fileEncoding; /** Maps file paths to internal info instances. */ protected Map m_fileName2lineIndex; /** The path to the underlying file. */ protected String m_filePath; /** The path to the root for all accessible files. */ protected String m_rootPath; /** * If value is <code>true</code>, all setter methods will throw a * <code>{@link CmsRuntimeException}</code><p>. * * Only the method <code>{@link #clone()}</code> returns a clone that has set this * member to <code>false</code> allowing modification to take place.<p> */ private boolean m_frozen; /** * If true the represented file is a standard OpenCms log file and may be displayed * in more convenient ways (in future versions) because the format is known. */ private boolean m_isLogfile; /** The current window (numbered from zero to amount of possible different windows). */ protected int m_windowPos; /** The amount of lines to show. */ protected int m_windowSize; /** * Creates an instance with default settings that tries to use the log file path obtained * from <code>{@link OpenCms}'s {@link org.opencms.main.CmsSystemInfo}</code> instance.<p> * * If the log file path is invalid or not configured correctly a logging is performed and the * path remains empty to allow user-specified file selection.<p> */ public CmsRfsFileViewer() { if (OpenCms.getRunLevel() >= OpenCms.RUNLEVEL_3_SHELL_ACCESS) { m_rootPath = new File(OpenCms.getSystemInfo().getLogFileRfsPath()).getParent(); } m_isLogfile = true; m_fileName2lineIndex = new HashMap(); // system default charset: see http://java.sun.com/j2se/corejava/intl/reference/faqs/index.html#default-encoding m_fileEncoding = Charset.forName(new OutputStreamWriter(new ByteArrayOutputStream()).getEncoding()); m_enabled = true; m_windowSize = 200; } /** * Internal helper that throws a <code>{@link CmsRuntimeException}</code> if the * configuration of this instance has been frozen ({@link #setFrozen(boolean)}).<p> * * @throws CmsRuntimeException if the configuration of this instance has been frozen * ({@link #setFrozen(boolean)}) */ private void checkFrozen() throws CmsRuntimeException { if (m_frozen) { throw new CmsRuntimeException(Messages.get().container(Messages.ERR_FILE_VIEW_SETTINGS_FROZEN_0)); } } /** * Returns a clone of this file view settings that is not "frozen" and therefore allows modifications.<p> * * Every instance that plans to modify settings has to obtain a clone first that may be * modified. The original instance returned from * (<code>{@link org.opencms.workplace.CmsWorkplaceManager#getFileViewSettings()}</code>) will throw * a <code>{@link CmsRuntimeException}</code> for each setter invocation. <p> * * @return a clone of this file view settings that is not "frozen" and therefore allows modifications */ public Object clone() { // first run after installation: filePath & rootPath is null: if (m_filePath == null) { // below that runlevel the following call will fail (not initialized from config yet): if (OpenCms.getRunLevel() >= OpenCms.RUNLEVEL_3_SHELL_ACCESS) { m_filePath = OpenCms.getSystemInfo().getLogFileRfsPath(); } } if (m_rootPath == null) { if (OpenCms.getRunLevel() >= OpenCms.RUNLEVEL_3_SHELL_ACCESS) { m_rootPath = new File(OpenCms.getSystemInfo().getLogFileRfsPath()).getParent(); } } CmsRfsFileViewer clone = new CmsRfsFileViewer(); clone.m_rootPath = m_rootPath; try { // strings are immutable: no outside modification possible. clone.setFilePath(m_filePath); } catch (CmsRfsException e) { // will never happen because m_filePath was verified in setFilePath of this instance. } catch (CmsRuntimeException e) { // will never happen because m_filePath was verified in setFilePath of this instance. } clone.m_fileEncoding = m_fileEncoding; clone.m_isLogfile = m_isLogfile; clone.m_enabled = m_enabled; //clone.m_windowPos = m_windowPos; clone.setWindowSize(m_windowSize); clone.m_fileName2lineIndex = m_fileName2lineIndex; // allow clone-modifications. clone.m_frozen = false; return clone; } /** * Returns the canonical name of the character encoding of the underlying file.<p> * * If no special choice is fed into * <code>{@link #setFileEncoding(String)}</code> before this call * always the system default character encoding is returned.<p> * * This value may be ignored outside and will be ignored inside if the * underlying does not contain textual content.<p> * * @return the canonical name of the character encoding of the underlying file */ public String getFileEncoding() { return m_fileEncoding.name(); } /** * Returns the path denoting the file that is accessed.<p> * * @return the path denoting the file that is accessed */ public String getFilePath() { return m_filePath; } /** * Returns true if the view's internal file path points to a log file in standard OpenCms format.<p> * * @return true if the view's internal file path points to a log file in standard OpenCms format */ public boolean getIsLogfile() { // method name is bean-convention of apache.commons.beanutils (unlike eclipse's convention for booleans) return m_isLogfile; } /** * Returns the start position of the current display.<p> * * This is a count of "windows" that * consist of viewable text with "windowSize" lines of text (for a non-standard log file) or * log-entries (for a standard log file).<p> * * @return the start position of the current display */ public int getWindowPos() { return m_windowPos; } /** * Returns the path denoting the root folder for all accessible files.<p> * * @return the path denoting the root folder for all accessible files */ public String getRootPath() { return m_rootPath; } /** * Get the amount of lines (or entries depending on whether a standard log file is shown) * to display per page. <p> * * @return the amount of lines to display per page */ public int getWindowSize() { return m_windowSize; } /** * Returns true if this view upon the underlying file via * <code>{@link #readFilePortion()}</code> is enabled.<p> * * * @return true if this view upon the underlying file via * <code>{@link #readFilePortion()}</code> is enabled.<p> */ public boolean isEnabled() { return m_enabled; } /** * Return the view portion of lines of text from the underlying file or an * empty String if <code>{@link #isEnabled()}</code> returns <code>false</code>.<p> * * @return the view portion of lines of text from the underlying file or an * empty String if <code>{@link #isEnabled()}</code> returns <code>false</code> * @throws CmsRfsException if something goes wrong */ public String readFilePortion() throws CmsRfsException { if (m_enabled) { // if we want to view the log file we have to set the internal m_windowPos to the last window // to view the end: int lines = -1; int startLine; if (m_isLogfile) { lines = scrollToFileEnd(); // for logfile mode we show the last window of window size: // it could be possible that only 4 lines are in the last window // (e.g.: 123 lines with windowsize 10 -> last window has 3 lines) // so we ignore the window semantics and show the n last lines: startLine = lines - m_windowSize; } else { m_windowPos = 0; startLine = m_windowPos * m_windowSize; } LineNumberReader reader = null; try { // don't make the buffer too big, just big enough for windowSize lines (estimation: avg. of 200 characters per line) // to save reading too much (this optimizes to read the first windows, much later windows will be slower...) reader = new LineNumberReader( new BufferedReader(new InputStreamReader(new FileInputStream(m_filePath), m_fileEncoding)), m_windowSize * 200); int currentLine = 0; // skip the lines to the current window: while (startLine > currentLine) { reader.readLine(); currentLine++; } StringBuffer result = new StringBuffer(); String read = reader.readLine(); // logfile treatment is different // we invert the lines: latest come first if (m_isLogfile) { // stack is java hall of shame member... but standard Stack inverter = new Stack(); for (int i = m_windowSize; (i > 0) && (read != null); i--) { inverter.push(read); read = reader.readLine(); } // pop-off: while (!inverter.isEmpty()) { result.append(inverter.pop()); result.append('\n'); } } else { for (int i = m_windowSize; (i > 0) && (read != null); i--) { result.append(read); result.append('\n'); read = reader.readLine(); } } return CmsEncoder.escapeXml(result.toString()); } catch (IOException ioex) { CmsRfsException ex = new CmsRfsException( Messages.get().container(Messages.ERR_FILE_ARG_ACCESS_1, m_filePath), ioex); throw ex; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LOG.error(e.getLocalizedMessage(), e); } } } } else { return Messages.get().getBundle().key(Messages.GUI_FILE_VIEW_NO_PREVIEW_0); } } /** * Internally sets the member <code>m_windowPos</code> to the last available * window of <code>m_windowSize</code> windows to let further calls to * <code>{@link #readFilePortion()}</code> display the end of the file. <p> * * This method is triggered when a new file is chosen * (<code>{@link #setFilePath(String)}</code>) because the amount of lines changes. * This method is also triggered when a different window size is chosen * (<code>{@link #setWindowSize(int)}</code>) because the amount of lines to display change. * * @return the amount of lines in the file to view */ private int scrollToFileEnd() { int lines = 0; if (OpenCms.getRunLevel() < OpenCms.RUNLEVEL_3_SHELL_ACCESS) { // no scrolling if system not yet fully initialized } else { LineNumberReader reader = null; // shift the window position to the end of the file: this is expensive but OK for ocs logfiles as they // are ltd. to 2 MB try { reader = new LineNumberReader( new BufferedReader(new InputStreamReader(new FileInputStream(m_filePath)))); while (reader.readLine() != null) { lines++; } reader.close(); // if 11.75 windows are available, we don't want to end on window nr. 10 int availWindows = (int) Math.ceil((double) lines / (double) m_windowSize); // we start with window 0 m_windowPos = availWindows - 1; } catch (IOException ioex) { LOG.error("Unable to scroll file " + m_filePath + " to end. Ensure that it exists. "); } finally { if (reader != null) { try { reader.close(); } catch (Throwable f) { LOG.info("Unable to close reader of file " + m_filePath, f); } } } } return lines; } /** * Set the boolean that decides if the view to the underlying file via * <code>{@link #readFilePortion()}</code> is enabled.<p> * * @param preview the boolean that decides if the view to the underlying file via * <code>{@link #readFilePortion()}</code> is enabled */ public void setEnabled(boolean preview) { m_enabled = preview; } /** * Set the character encoding of the underlying file.<p> * * The given String has to match a valid char set name (canonical or alias) * of one of the system's supported <code>{@link Charset}</code> instances * (see <code>{@link Charset#forName(java.lang.String)}</code>).<p> * * This setting will be used for reading the file. This enables to correctly * display files with text in various encodings in UIs.<p> * * @param fileEncoding the character encoding of the underlying file to set */ public void setFileEncoding(String fileEncoding) { checkFrozen(); try { m_fileEncoding = Charset.forName(fileEncoding); } catch (IllegalCharsetNameException icne) { throw new CmsIllegalArgumentException( Messages.get().container(Messages.ERR_CHARSET_ILLEGAL_NAME_1, fileEncoding)); } catch (UnsupportedCharsetException ucse) { throw new CmsIllegalArgumentException( Messages.get().container(Messages.ERR_CHARSET_UNSUPPORTED_1, fileEncoding)); } } /** * Set the path in the real file system that points to the file * that should be displayed.<p> * * This method will only success if the file specified by the <code>path</code> * argument is valid within the file system, no folder and may be read by the * OpenCms process on the current platform.<p> * * @param path the path in the real file system that points to the file that should be displayed to set * * @throws CmsRuntimeException if the configuration of this instance has been frozen * @throws CmsRfsException if the given path is invalid, does not point to a file or cannot be accessed */ public void setFilePath(String path) throws CmsRfsException, CmsRuntimeException { checkFrozen(); if (path != null) { // leading whitespace from CmsComboWidget causes exception path = path.trim(); } if (CmsStringUtil.isEmpty(path)) { throw new CmsRfsException( Messages.get().container(Messages.ERR_FILE_ARG_EMPTY_1, new Object[] { String.valueOf(path) })); } try { // just for validation : File file = new File(path); if (file.isDirectory()) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_filePath = null; m_isLogfile = true; } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_IS_FOLDER_1, new Object[] { String.valueOf(path) })); } } else if (!file.isFile()) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_filePath = null; m_isLogfile = true; } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_NOT_FOUND_1, new Object[] { String.valueOf(path) })); } } else if (!file.canRead()) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_filePath = null; m_isLogfile = true; } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_NOT_READ_1, new Object[] { String.valueOf(path) })); } } else if ((m_rootPath != null) && !file.getCanonicalPath().startsWith(m_rootPath)) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_filePath = null; m_isLogfile = true; } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_NOT_READ_1, new Object[] { String.valueOf(path) })); } } else { m_filePath = file.getCanonicalPath(); } } catch (FileNotFoundException fnfe) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_filePath = null; m_isLogfile = true; } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_NOT_FOUND_1, new Object[] { String.valueOf(path) }), fnfe); } } catch (IOException ioex) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_filePath = null; m_isLogfile = true; } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_ACCESS_1, new Object[] { String.valueOf(path) }), ioex); } } } /** * Package friendly access that allows the <code>{@link org.opencms.workplace.CmsWorkplaceManager}</code> * to "freeze" this instance within the system-wide assignment in it's * <code>{@link org.opencms.workplace.CmsWorkplaceManager#setFileViewSettings(org.opencms.file.CmsObject, CmsRfsFileViewer)}</code> method.<p> * * @param frozen if true this instance will freeze and throw <code>CmsRuntimeExceptions</code> upon setter invocations * * @throws CmsRuntimeException if the configuration of this instance has been frozen * ({@link #setFrozen(boolean)}) */ public void setFrozen(boolean frozen) throws CmsRuntimeException { m_frozen = frozen; } /** * Set if the internal file is in standard log file format (true) or not (false).<p> * * If set to true the file might be * treated / displayed in a more convenient format than standard files in future. * Currently it is only inverted (last lines appear first) and only the last * 'Window Size' lines of the file are displayed.<p> * * Do not activate this (it is possible from the log file viewer settings in the workplace * administration) if your selected file is no log file: The display will confuse you and * be more expensive (imaging scrolling a 20 MB file to view the last 200 lines). <p> * * @param isLogfile determines if the internal file is in standard log file format (true) or not (false) * * @throws CmsRuntimeException if the configuration of this instance has been frozen * ({@link #setFrozen(boolean)}) */ public void setIsLogfile(boolean isLogfile) throws CmsRuntimeException { checkFrozen(); m_isLogfile = isLogfile; } /** * Set the path in the real file system that points to the folder/tree * containing the log files.<p> * * This method will only success if the folder specified by the <code>path</code> * argument is valid within the file system.<p> * * @param path the path in the real file system that points to the folder containing the log files * * @throws CmsRuntimeException if the configuration of this instance has been frozen * @throws CmsRfsException if the given path is invalid */ public void setRootPath(String path) throws CmsRfsException, CmsRuntimeException { checkFrozen(); if (path != null) { // leading whitespace from CmsComboWidget causes exception path = path.trim(); } if (CmsStringUtil.isEmpty(path)) { throw new CmsRfsException( Messages.get().container(Messages.ERR_FILE_ARG_EMPTY_1, new Object[] { String.valueOf(path) })); } try { // just for validation : File file = new File(path); if (file.exists()) { m_rootPath = file.getCanonicalPath(); } else { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry m_rootPath = new File(OpenCms.getSystemInfo().getLogFileRfsPath()).getParent(); } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_NOT_FOUND_1, new Object[] { String.valueOf(path) })); } } } catch (IOException ioex) { // if wrong configuration perform self healing: if (OpenCms.getRunLevel() == OpenCms.RUNLEVEL_2_INITIALIZING) { // this deletes the illegal entry and will default to the log file path m_rootPath = new File(OpenCms.getSystemInfo().getLogFileRfsPath()).getParent(); } else { throw new CmsRfsException(Messages.get().container(Messages.ERR_FILE_ARG_ACCESS_1, new Object[] { String.valueOf(path) }), ioex); } } } /** * Sets the start position of the current display.<p> * * This is a count of "windows" that * consist of viewable text with "windowSize" lines of text (for a non-standard log file) or * log-entries (for a standard log file).<p> * * @param windowPos the start position of the current display to set * * @throws CmsRuntimeException if the configuration of this instance has been frozen * ({@link #setFrozen(boolean)}) */ public void setWindowPos(int windowPos) throws CmsRuntimeException { checkFrozen(); m_windowPos = windowPos; } /** * Set the amount of lines (or entries depending on whether a standard log file is shown) * to display per page.<p> * * @param windowSize the amount of lines to display per page * * @throws CmsRuntimeException if the configuration of this instance has been frozen * ({@link #setFrozen(boolean)}) */ public void setWindowSize(int windowSize) throws CmsRuntimeException { checkFrozen(); m_windowSize = windowSize; } }