| /* |
| * 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 |
| <<<<<<< Updated upstream |
| * |
| * 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 |
| ======= |
| * |
| * https://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 |
| >>>>>>> Stashed changes |
| * limitations under the License. |
| */ |
| |
| package org.apache.jdo.tck.util; |
| |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.util.logging.ErrorManager; |
| import java.util.logging.Filter; |
| import java.util.logging.Formatter; |
| import java.util.logging.Handler; |
| import java.util.logging.Level; |
| import java.util.logging.LogManager; |
| import java.util.logging.LogRecord; |
| import java.util.logging.SimpleFormatter; |
| import java.util.logging.StreamHandler; |
| |
| /** |
| * A JDK1.4 logging Handler class which delegates to a file handler. Configuration: By default each |
| * TCKFileHandler is initialized using the following LogManager configuration properties: |
| * |
| * <ul> |
| * <li>java.util.logging.TCKFileHandler.level specifies the default level for the Handler |
| * (defaults to Level.ALL). |
| * <li>java.util.logging.FileHandler.filter specifies the name of a Filter class to use (defaults |
| * to no Filter). |
| * <li>java.util.logging.FileHandler.formatter specifies the name of a Formatter class to use |
| * (defaults to java.util.logging.SimpleFormatter). |
| * <li>java.util.logging.FileHandler.encoding the name of the character set encoding to use |
| * (defaults to the default platform encoding). |
| * <li>java.util.logging.FileHandler.fileName specifies a the output file name. See below for |
| * details. |
| * <li>java.util.logging.FileHandler.append specifies whether the FileHandler should append onto |
| * any existing files (defaults to false). |
| * </ul> |
| * |
| * For details on the construction of the file name see method {@link |
| * BatchTestRunner#changeFileName(String)}. |
| */ |
| public class TCKFileHandler extends Handler { |
| |
| private static final String defaultName = ""; |
| private static final boolean defaultAppend = false; |
| private static final Level defaultLevel = Level.ALL; |
| private static final Filter defaultFilter = null; |
| private static final Formatter defaultFormatter = new SimpleFormatter(); |
| private static final String defaultEncoding = null; |
| |
| private String fileName; |
| private boolean append; |
| |
| private Level level; |
| private Filter filter; |
| private Formatter formatter; |
| private String encoding; |
| |
| private FileHandlerDelegate delegate; |
| |
| /** |
| * @see Handler#Handler() |
| * @throws IOException IO exception |
| * @throws SecurityException securiyt exception |
| */ |
| public TCKFileHandler() throws IOException, SecurityException { |
| configure(); |
| |
| this.delegate = new FileHandlerDelegate(); |
| |
| OutputStream stream = new FileOutputStream(this.fileName, this.append); |
| this.delegate.setOutputStream(stream); |
| |
| this.delegate.setLevel(this.level); |
| this.delegate.setFilter(this.filter); |
| this.delegate.setFormatter(this.formatter); |
| this.delegate.setEncoding(this.encoding); |
| } |
| |
| /** |
| * @see Handler#publish(java.util.logging.LogRecord) |
| */ |
| public synchronized void publish(LogRecord record) { |
| this.delegate.publish(record); |
| } |
| |
| /** |
| * @see Handler#close() |
| */ |
| public synchronized void close() throws SecurityException { |
| this.delegate.close(); |
| } |
| |
| /** |
| * @see Handler#flush() |
| */ |
| public void flush() { |
| this.delegate.flush(); |
| } |
| |
| /** |
| * @see Handler#getEncoding() |
| */ |
| @Override |
| public String getEncoding() { |
| return this.encoding; |
| } |
| |
| /** |
| * @see Handler#getErrorManager() |
| */ |
| @Override |
| public ErrorManager getErrorManager() { |
| return this.delegate.getErrorManager(); |
| } |
| |
| /** |
| * @see Handler#getFilter() |
| */ |
| @Override |
| public Filter getFilter() { |
| return this.filter; |
| } |
| |
| /** |
| * @see Handler#getFormatter() |
| */ |
| @Override |
| public Formatter getFormatter() { |
| return this.formatter; |
| } |
| |
| /** |
| * @see Handler#getLevel() |
| */ |
| @Override |
| public Level getLevel() { |
| return this.level; |
| } |
| |
| /** |
| * @see Handler#reportError(java.lang.String, java.lang.Exception, int) |
| */ |
| @Override |
| protected void reportError(String msg, Exception ex, int code) { |
| this.delegate.reportError(msg, ex, code); |
| } |
| |
| /** |
| * @see Handler#setErrorManager(java.util.logging.ErrorManager) |
| */ |
| @Override |
| public void setErrorManager(ErrorManager em) { |
| this.delegate.setErrorManager(em); |
| } |
| |
| /** |
| * @see StreamHandler#isLoggable(java.util.logging.LogRecord) |
| */ |
| @Override |
| public boolean isLoggable(LogRecord record) { |
| return this.delegate.isLoggable(record); |
| } |
| |
| /** |
| * Sets the file name fileName property. |
| * |
| * @param fileName The fileName to set |
| */ |
| protected void setPattern(String fileName) { |
| this.fileName = BatchTestRunner.changeFileName(fileName); |
| } |
| |
| /** |
| * Sets the append property. |
| * |
| * @param append The append to set. |
| */ |
| protected void setAppend(boolean append) { |
| this.append = append; |
| } |
| |
| /** |
| * Sets the level property. |
| * |
| * @param level The level to set. |
| */ |
| @Override |
| public void setLevel(Level level) { |
| this.level = level; |
| if (this.delegate != null) { |
| this.delegate.setLevel(level); |
| } |
| } |
| |
| /** |
| * Sets the filter property. |
| * |
| * @param filter The filter to set. |
| */ |
| @Override |
| public void setFilter(Filter filter) { |
| this.filter = filter; |
| if (this.delegate != null) { |
| this.delegate.setFilter(filter); |
| } |
| } |
| |
| /** |
| * Sets the formatter property. |
| * |
| * @param formatter The formatter to set. |
| */ |
| @Override |
| public void setFormatter(Formatter formatter) { |
| this.formatter = formatter; |
| if (this.delegate != null) { |
| this.delegate.setFormatter(formatter); |
| } |
| } |
| |
| /** |
| * Sets the encoding property. |
| * |
| * @param encoding The encoding to set. |
| * @throws UnsupportedEncodingException encoding not supported |
| * @throws SecurityException security exception |
| */ |
| @Override |
| public void setEncoding(String encoding) throws SecurityException, UnsupportedEncodingException { |
| this.encoding = encoding; |
| if (this.delegate != null) { |
| this.delegate.setEncoding(encoding); |
| } |
| } |
| |
| /** |
| * Sets the delegate. |
| * |
| * @param delegate The delegate to set. |
| */ |
| protected void setDelegate(FileHandlerDelegate delegate) { |
| this.delegate = delegate; |
| } |
| |
| private void configure() { |
| LogManager manager = LogManager.getLogManager(); |
| String className = this.getClass().getName(); |
| |
| setPattern(getStringProperty(manager, className + ".fileName", defaultName)); |
| setAppend(getBooleanProperty(manager, className + ".append", defaultAppend)); |
| |
| setLevel(getLevelProperty(manager, className + ".level", defaultLevel)); |
| setFilter(getFilterProperty(manager, className + ".filter", defaultFilter)); |
| setFormatter(getFormatterProperty(manager, className + ".formatter", defaultFormatter)); |
| try { |
| setEncoding(getStringProperty(manager, className + ".encoding", defaultEncoding)); |
| } catch (Exception e) { |
| try { |
| setEncoding(defaultEncoding); |
| } catch (Exception ignored) { |
| } |
| } |
| } |
| |
| private boolean getBooleanProperty(LogManager manager, String property, boolean defaultValue) { |
| boolean result = defaultValue; |
| String value = manager.getProperty(property); |
| if (value != null) { |
| try { |
| result = Boolean.valueOf(value.trim()).booleanValue(); |
| } catch (Exception ignored) { |
| } |
| } |
| return result; |
| } |
| |
| private String getStringProperty(LogManager manager, String property, String defaultValue) { |
| String result = defaultValue; |
| String value = manager.getProperty(property); |
| if (value != null) { |
| result = value.trim(); |
| } |
| return result; |
| } |
| |
| private Level getLevelProperty(LogManager manager, String property, Level defaultValue) { |
| Level result = defaultValue; |
| String value = manager.getProperty(property); |
| if (value != null) { |
| try { |
| result = Level.parse(value.trim()); |
| } catch (Exception ignored) { |
| } |
| } |
| return result; |
| } |
| |
| private Filter getFilterProperty(LogManager manager, String property, Filter defaultValue) { |
| return (Filter) newInstanceForProperty(manager, property, defaultValue); |
| } |
| |
| private Formatter getFormatterProperty( |
| LogManager manager, String property, Formatter defaultValue) { |
| return (Formatter) newInstanceForProperty(manager, property, defaultValue); |
| } |
| |
| private Object newInstanceForProperty(LogManager manager, String property, Object defaultValue) { |
| Object result = defaultValue; |
| String value = manager.getProperty(property); |
| if (value != null) { |
| try { |
| Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass(value); |
| result = clazz.getDeclaredConstructor().newInstance(); |
| } catch (Exception ignored) { |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * This class has been defined to make method {@link Handler#reportError(java.lang.String, |
| * java.lang.Exception, int)} accessible in the outer class. |
| */ |
| private static class FileHandlerDelegate extends StreamHandler { |
| |
| @Override |
| protected void setOutputStream(OutputStream out) { |
| super.setOutputStream(out); |
| } |
| |
| /** |
| * @see Handler#reportError(java.lang.String, java.lang.Exception, int) |
| */ |
| @Override |
| protected void reportError(String msg, Exception ex, int code) { |
| super.reportError(msg, ex, code); |
| } |
| } |
| } |