/**
* Copyright Microsoft Corporation
*
* Licensed 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
* 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
* limitations under the License.
*/
package com.microsoft.azure.storage.analytics;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.UUID;
import org.apache.commons.lang3.StringEscapeUtils;
import com.microsoft.azure.storage.core.SR;
import com.microsoft.azure.storage.core.Utility;
/**
* RESERVED FOR INTERNAL USE. Reads LogRecord information from an InputStream.
*/
class LogRecordStreamReader extends InputStreamReader {
/**
* Holds the field delimiter character.
*/
public static final char FIELD_DELIMITER = ';';
/**
* Holds the record delimiter character.
*/
public static final char RECORD_DELIMITER = '\n';
/**
* Holds the quote character.
*/
public static final char QUOTE_CHAR = '"';
/**
* Flag that indicates whether this is the start of a record.
*/
private boolean isFirstFieldInRecord;
/**
* Peeked character, if it has been pulled already.
*/
private Integer peekedCharacter = null;
/**
* Constructs a new LogRecordStreamReader to read the stream given.
*
* @param stream
*/
public LogRecordStreamReader(InputStream stream) {
super(stream);
this.isFirstFieldInRecord = true;
}
/**
* Checks if another field exists in the record.
*
* @return
* true if another field exists, false otherwise.
* @throws IOException
*/
public boolean hasMoreFieldsInRecord() throws IOException {
return this.tryPeekDelimiter(LogRecordStreamReader.FIELD_DELIMITER);
}
/**
* Checks to see if the end of the stream has been reached.
*
* @return
* true if at the end of the stream, false otherwise.
* @throws IOException
*/
public boolean isEndOfFile() throws IOException {
return (this.peek() == -1);
}
/**
* Read a String from the stream.
*
* @return
* the String read.
* @throws IOException
*/
public String readString() throws IOException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return temp;
}
}
/**
* Read a quoted String from the stream.
*
* @return
* the String read.
* @throws IOException
*/
public String readQuotedString() throws IOException {
String temp = this.readField(true /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return temp;
}
}
/**
* Read a Boolean from the stream.
*
* @return
* the Boolean read.
* @throws IOException
*/
public Boolean readBoolean() throws IOException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return Boolean.parseBoolean(temp);
}
}
/**
* Read a Date from the stream.
*
* @param format
* the format in which the date is stored, for parsing purposes.
* @return
* the Date read.
* @throws IOException
* @throws ParseException
*/
public Date readDate(DateFormat format) throws IOException, ParseException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return format.parse(temp);
}
}
/**
* Read a Double from the stream.
*
* @return
* the Double read.
* @throws IOException
*/
public Double readDouble() throws IOException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return Double.parseDouble(temp);
}
}
/**
* Read a UUID from the stream.
*
* @return
* the UUID read.
* @throws IOException
*/
public UUID readUuid() throws IOException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return UUID.fromString(temp);
}
}
/**
* Read an Integer from the stream.
*
* @return
* the Integer read.
* @throws IOException
*/
public Integer readInteger() throws IOException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return Integer.parseInt(temp);
}
}
/**
* Read a Long from the stream.
*
* @return
* the Long read.
* @throws IOException
*/
public Long readLong() throws IOException {
String temp = this.readField(false /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return Long.parseLong(temp);
}
}
/**
* Read a URI from the stream.
*
* @return
* the URI read.
* @throws URISyntaxException
* @throws IOException
*/
public URI readUri() throws URISyntaxException, IOException {
String temp = this.readField(true /* isQuotedString */);
if (Utility.isNullOrEmpty(temp)) {
return null;
}
else {
return new URI(StringEscapeUtils.unescapeHtml4(temp));
}
}
/**
* Ends the current record by reading the record delimiter and adjusting internal state.
*
* @throws IOException
*/
public void endCurrentRecord() throws IOException {
this.readDelimiter(LogRecordStreamReader.RECORD_DELIMITER);
this.isFirstFieldInRecord = true;
}
/**
* Read a delimiter from the stream.
*
* @param delimiter
* the delimiter to read.
* @throws IOException
*/
private void readDelimiter(char delimiter) throws IOException {
if (this.isEndOfFile()) {
throw new EOFException(SR.LOG_STREAM_END_ERROR);
}
else {
int read = this.read();
if (read == -1 || (char) read != delimiter) {
throw new IllegalStateException(SR.LOG_STREAM_DELIMITER_ERROR);
}
}
}
/**
* Checks to see if the next character is the delimiter expected.
*
* @param delimiter
* the delimiter to try to peek.
* @return
* @throws IOException
*/
private boolean tryPeekDelimiter(char delimiter) throws IOException {
if (this.isEndOfFile()) {
throw new EOFException(SR.LOG_STREAM_END_ERROR);
}
else {
if ((char) this.peek() != delimiter) {
return false;
}
else {
return true;
}
}
}
/**
* Read a field from the stream.
*
* @param isQuotedString
* whether the field is encased in quotes and escaped.
* @return
* the field read.
* @throws IOException
*/
private String readField(boolean isQuotedString) throws IOException {
if (!this.isFirstFieldInRecord) {
this.readDelimiter(LogRecordStreamReader.FIELD_DELIMITER);
}
else {
this.isFirstFieldInRecord = false;
}
// Read a field, handling field/record delimiters in quotes and not counting them,
// and also check that there are no record delimiters since they are only expected
// outside of a field.
// Note: We only need to handle strings that are quoted once from the beginning,
// (e.g. "mystring"). We do not need to handle nested quotes or anything because
// we control the string format.
StringBuilder fieldBuilder = new StringBuilder();
boolean hasSeenQuoteForQuotedString = false;
boolean isExpectingDelimiterForNextCharacterForQuotedString = false;
while (true) {
// If EOF when we haven't read the delimiter; unexpected.
if (this.isEndOfFile()) {
throw new EOFException(SR.LOG_STREAM_END_ERROR);
}
// Since we just checked isEndOfFile above, we know this is a char.
char c = (char) this.peek();
// If we hit a delimiter that is not quoted or we hit the delimiter for
// a quoted string or we hit the empty value string and hit a delimiter,
// then we have finished reading the field.
// Note: The empty value string is the only string that we don't require
// quotes for for a quoted string.
if ((!isQuotedString || isExpectingDelimiterForNextCharacterForQuotedString || fieldBuilder.length() == 0)
&& (c == LogRecordStreamReader.FIELD_DELIMITER || c == LogRecordStreamReader.RECORD_DELIMITER)) {
// The delimiter character was peeked but not read -- they'll be consumed
// on either the next call to readField or to EndCurrentRecord.
break;
}
if (isExpectingDelimiterForNextCharacterForQuotedString) {
// We finished reading a quoted string but found no delimiter following it.
throw new IllegalStateException(SR.LOG_STREAM_QUOTE_ERROR);
}
// The character was not a delimiter, so consume and add to builder.
this.read();
fieldBuilder.append(c);
// We need to handle quotes specially since quoted delimiters
// do not count since they are considered to be part of the
// quoted string and not actually a delimiter.
// Note: We use a specific quote character since we control the format
// and we only allow non-encoded quote characters at the beginning/end
// of the string.
if (c == LogRecordStreamReader.QUOTE_CHAR) {
if (!isQuotedString) {
// Non-encoded quote character only allowed for quoted strings.
throw new IllegalStateException(SR.LOG_STREAM_QUOTE_ERROR);
}
else if (fieldBuilder.length() == 1) {
// Opening quote for a quoted string.
hasSeenQuoteForQuotedString = true;
}
else if (hasSeenQuoteForQuotedString) {
// Closing quote for a quoted string.
isExpectingDelimiterForNextCharacterForQuotedString = true;
}
else {
// Unexpected non-encoded quote.
throw new IllegalStateException(SR.LOG_STREAM_QUOTE_ERROR);
}
}
}
String field;
// Note: For quoted strings we remove the quotes.
// We do not do this for the empty value string since it represents empty
// and we don't write that out in quotes even for quoted strings.
if (isQuotedString && fieldBuilder.length() != 0) {
field = fieldBuilder.substring(1, fieldBuilder.length() - 1);
}
else {
field = fieldBuilder.toString();
}
return field;
}
@Override
public int read() throws IOException {
// Before calling the super, check to see if a char has been peeked.
// Short circuit, reset it, and return it if so.
if (this.peekedCharacter != null) {
int temp = this.peekedCharacter;
this.peekedCharacter = null;
return temp;
}
else {
return super.read();
}
}
/**
* Peek a character from the stream. This character is not consumed until read() is called.
*
* @return
* the character peeked, or -1 if none exist.
* @throws IOException
*/
protected int peek() throws IOException {
if (this.peekedCharacter != null) {
// If we already have peeked, just return that.
return this.peekedCharacter;
}
else {
this.peekedCharacter = super.read();
return this.peekedCharacter;
}
}
}