001    /* 
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     *  contributor license agreements.  See the NOTICE file distributed with
004     *  this work for additional information regarding copyright ownership.
005     *  The ASF licenses this file to You under the Apache License, Version 2.0
006     *  (the "License"); you may not use this file except in compliance with
007     *  the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     *  Unless required by applicable law or agreed to in writing, software
012     *  distributed under the License is distributed on an "AS IS" BASIS,
013     *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     *  See the License for the specific language governing permissions and
015     *  limitations under the License.
016     *
017     */
018    
019    package org.apache.commons.exec;
020    
021    import java.io.ByteArrayOutputStream;
022    import java.io.IOException;
023    import java.io.OutputStream;
024    
025    /**
026     * Base class to connect a logging system to the output and/or
027     * error stream of then external process. The implementation
028     * parses the incoming data to construct a line and passes
029     * the complete line to an user-defiend implementation.
030     */
031    public abstract class LogOutputStream
032      extends OutputStream {
033    
034        /** Initial buffer size. */
035        private static final int INTIAL_SIZE = 132;
036    
037        /** Carriage return */
038        private static final int CR = 0x0d;
039    
040        /** Linefeed */
041        private static final int LF = 0x0a;
042    
043        /** the internal buffer */
044        private final ByteArrayOutputStream buffer = new ByteArrayOutputStream(
045          INTIAL_SIZE);
046    
047        private boolean skip = false;
048    
049        private final int level;
050    
051        /**
052         * Creates a new instance of this class.
053         * Uses the default level of 999.
054         */
055        public LogOutputStream() {
056            this(999);
057        }
058    
059        /**
060         * Creates a new instance of this class.
061         *
062         * @param level loglevel used to log data written to this stream.
063         */
064        public LogOutputStream(final int level) {
065            this.level = level;
066        }
067    
068        /**
069         * Write the data to the buffer and flush the buffer, if a line separator is
070         * detected.
071         *
072         * @param cc data to log (byte).
073         * @see java.io.OutputStream#write(int)
074         */
075        public void write(final int cc) throws IOException {
076            final byte c = (byte) cc;
077            if ((c == '\n') || (c == '\r')) {
078                if (!skip) {
079                    processBuffer();
080                }
081            } else {
082                buffer.write(cc);
083            }
084            skip = (c == '\r');
085        }
086    
087        /**
088         * Flush this log stream.
089         *
090         * @see java.io.OutputStream#flush()
091         */
092        public void flush() {
093            if (buffer.size() > 0) {
094                processBuffer();
095            }
096        }
097    
098        /**
099         * Writes all remaining data from the buffer.
100         *
101         * @see java.io.OutputStream#close()
102         */
103        public void close() throws IOException {
104            if (buffer.size() > 0) {
105                processBuffer();
106            }
107            super.close();
108        }
109    
110        /**
111         * @return the trace level of the log system
112         */
113        public int getMessageLevel() {
114            return level;
115        }
116    
117        /**
118         * Write a block of characters to the output stream
119         *
120         * @param b the array containing the data
121         * @param off the offset into the array where data starts
122         * @param len the length of block
123         * @throws java.io.IOException if the data cannot be written into the stream.
124         * @see java.io.OutputStream#write(byte[], int, int)
125         */
126        public void write(final byte[] b, final int off, final int len)
127                throws IOException {
128            // find the line breaks and pass other chars through in blocks
129            int offset = off;
130            int blockStartOffset = offset;
131            int remaining = len;
132            while (remaining > 0) {
133                while (remaining > 0 && b[offset] != LF && b[offset] != CR) {
134                    offset++;
135                    remaining--;
136                }
137                // either end of buffer or a line separator char
138                int blockLength = offset - blockStartOffset;
139                if (blockLength > 0) {
140                    buffer.write(b, blockStartOffset, blockLength);
141                }
142                while (remaining > 0 && (b[offset] == LF || b[offset] == CR)) {
143                    write(b[offset]);
144                    offset++;
145                    remaining--;
146                }
147                blockStartOffset = offset;
148            }
149        }
150    
151        /**
152         * Converts the buffer to a string and sends it to <code>processLine</code>.
153         */
154        protected void processBuffer() {
155            processLine(buffer.toString());
156            buffer.reset();
157        }
158    
159        /**
160         * Logs a line to the log system of the user.
161         *
162         * @param line
163         *            the line to log.
164         */
165        protected void processLine(final String line) {
166            processLine(line, level);
167        }
168    
169        /**
170         * Logs a line to the log system of the user.
171         *
172         * @param line the line to log.
173         * @param level the log level to use
174         */
175        protected abstract void processLine(final String line, final int level);
176    }