/**
* Get text content of a source file.
*
* @param path The canonical path of source file.
* @param charset Source file encoding.
* @return Source file content.
*/
public String read(String path, String charset) {
String str = null;
byte[] bin = read(path);
try {
str = Charset.forName(charset).newDecoder().decode(ByteBuffer.wrap(bin)).toString();
} catch (CharacterCodingException e) {
App.exit("Cannot read " + path + " as " + charset + " encoded file");
}
return str;
}
/**
* Fills the time buffer with the formatted time.
*
* @param date current time in milliseconds
*/
private void fillTime(long date) throws IOException {
synchronized (_timeBuffer) {
if (date / 1000 == _lastTime / 1000) return;
if (_timeFormatSecondOffset >= 0 && date / 3600000 == _lastTime / 3600000) {
byte[] bBuf = _timeBuffer.getBuffer();
int min = (int) (date / 60000 % 60);
int sec = (int) (date / 1000 % 60);
bBuf[_timeFormatMinuteOffset + 0] = (byte) ('0' + min / 10);
bBuf[_timeFormatMinuteOffset + 1] = (byte) ('0' + min % 10);
bBuf[_timeFormatSecondOffset + 0] = (byte) ('0' + sec / 10);
bBuf[_timeFormatSecondOffset + 1] = (byte) ('0' + sec % 10);
_lastTime = date;
return;
}
_timeCharBuffer.clear();
QDate.formatLocal(_timeCharBuffer, date, _timeFormat);
if (_timeFormatSecondOffset >= 0) {
_timeFormatSecondOffset = _timeCharBuffer.lastIndexOf(':') + 1;
_timeFormatMinuteOffset = _timeFormatSecondOffset - 3;
}
char[] cBuf = _timeCharBuffer.getBuffer();
int length = _timeCharBuffer.getLength();
_timeBuffer.setLength(length);
byte[] bBuf = _timeBuffer.getBuffer();
for (int i = length - 1; i >= 0; i--) bBuf[i] = (byte) cBuf[i];
}
_lastTime = date;
}
/**
* Converts the given value into a desired byte order.
*
* @param aValue the value to convert;
* @param aByteCount the number of bytes that are supposed to be in the given value;
* @param aByteOrder the desired byte order.
* @return the converted value.
*/
public static int convertByteOrder(
final int aValue, final int aByteCount, final ByteOrder aByteOrder) {
if ((aByteCount <= 0) || (aByteCount > 32)) {
throw new IllegalArgumentException("Bit count cannot be zero, negative or beyond 32-bits!");
}
final ByteBuffer buf = ByteBuffer.allocate(aByteCount);
buf.putInt(aValue);
buf.order(aByteOrder);
buf.position(0);
final int result = buf.getInt();
return result;
}
/**
* Logs a request using the current format.
*
* @param request the servlet request.
* @param response the servlet response.
* @param buffer byte buffer containing the response
* @param offset buffer starting offset
* @param length length allowed in the buffer
* @return the new tail of the buffer
*/
private int log(
HttpServletRequestImpl request,
HttpServletResponseImpl responseFacade,
AbstractHttpResponse response,
byte[] buffer,
int offset,
int length)
throws IOException {
AbstractHttpRequest absRequest = request.getAbstractHttpRequest();
int len = _segments.length;
for (int i = 0; i < len; i++) {
Segment segment = _segments[i];
String value = null;
CharSegment csValue = null;
switch (segment._code) {
case Segment.TEXT:
int sublen = segment._data.length;
byte[] data = segment._data;
for (int j = 0; j < sublen; j++) buffer[offset++] = data[j];
break;
case Segment.CHAR:
buffer[offset++] = segment._ch;
break;
case 'b':
if (responseFacade.getStatus() == 304) buffer[offset++] = (byte) '-';
else offset = print(buffer, offset, response.getContentLength());
break;
// cookie
case 'c':
Cookie cookie = request.getCookie(segment._string);
if (cookie == null) cookie = responseFacade.getCookie(segment._string);
if (cookie == null) buffer[offset++] = (byte) '-';
else offset = print(buffer, offset, cookie.getValue());
break;
// set cookie
case Segment.SET_COOKIE:
ArrayList<Cookie> cookies = responseFacade.getCookies();
if (cookies == null || cookies.size() == 0) buffer[offset++] = (byte) '-';
else {
_cb.clear();
response.fillCookie(_cb, (Cookie) cookies.get(0), 0, 0, false);
offset = print(buffer, offset, _cb.getBuffer(), 0, _cb.getLength());
}
break;
case 'h':
if (isHostnameDnsLookup()) {
String addrName = request.getRemoteAddr();
InetAddress addr = InetAddress.getByName(addrName);
offset = print(buffer, offset, addr.getHostName());
} else offset = absRequest.printRemoteAddr(buffer, offset);
break;
// input header
case 'i':
csValue = absRequest.getHeaderBuffer(segment._string);
if (csValue == null) buffer[offset++] = (byte) '-';
else offset = print(buffer, offset, csValue);
break;
case 'l':
buffer[offset++] = (byte) '-';
break;
// request attribute
case 'n':
Object oValue = request.getAttribute(segment._string);
if (oValue == null) buffer[offset++] = (byte) '-';
else offset = print(buffer, offset, String.valueOf(oValue));
break;
// output header
case 'o':
value = response.getHeader(segment._string);
if (value == null) buffer[offset++] = (byte) '-';
else offset = print(buffer, offset, value);
break;
case 'r':
offset = print(buffer, offset, request.getMethod());
buffer[offset++] = (byte) ' ';
data = absRequest.getUriBuffer();
sublen = absRequest.getUriLength();
// server/02e9
if (buffer.length - offset - 128 < sublen) {
sublen = buffer.length - offset - 128;
System.arraycopy(data, 0, buffer, offset, sublen);
offset += sublen;
buffer[offset++] = (byte) '.';
buffer[offset++] = (byte) '.';
buffer[offset++] = (byte) '.';
} else {
System.arraycopy(data, 0, buffer, offset, sublen);
offset += sublen;
}
buffer[offset++] = (byte) ' ';
offset = print(buffer, offset, request.getProtocol());
break;
case 's':
int status = responseFacade.getStatus();
buffer[offset++] = (byte) ('0' + (status / 100) % 10);
buffer[offset++] = (byte) ('0' + (status / 10) % 10);
buffer[offset++] = (byte) ('0' + status % 10);
break;
case 't':
long date = Alarm.getCurrentTime();
if (date / 1000 != _lastTime / 1000) fillTime(date);
sublen = _timeBuffer.getLength();
data = _timeBuffer.getBuffer();
synchronized (_timeBuffer) {
System.arraycopy(data, 0, buffer, offset, sublen);
}
offset += sublen;
break;
case 'T':
{
long startTime = request.getStartTime();
long endTime = Alarm.getCurrentTime();
offset = print(buffer, offset, (int) ((endTime - startTime + 500) / 1000));
break;
}
case 'D':
{
long startTime = request.getStartTime();
long endTime = Alarm.getCurrentTime();
offset = print(buffer, offset, (int) ((endTime - startTime) * 1000));
break;
}
case 'u':
value = request.getRemoteUser(false);
if (value == null) buffer[offset++] = (byte) '-';
else {
buffer[offset++] = (byte) '"';
offset = print(buffer, offset, value);
buffer[offset++] = (byte) '"';
}
break;
case 'v':
value = request.getServerName();
if (value == null) buffer[offset++] = (byte) '-';
else {
offset = print(buffer, offset, value);
}
break;
case 'U':
offset = print(buffer, offset, request.getRequestURI());
break;
default:
throw new IOException();
}
}
return offset;
}
private ByteEncoder() {
_buf = ByteBuffer.allocateDirect(MAX_OBJECT_SIZE + 2048);
_buf.order(Bytes.ORDER);
}
/**
* method to extract the next monitor entry from the instrumentation memory. assumes that
* nextEntry is the offset into the byte array at which to start the search for the next entry.
* method leaves next entry pointing to the next entry or to the end of data.
*/
protected Monitor getNextMonitorEntry() throws MonitorException {
Monitor monitor = null;
// entries are always 4 byte aligned.
if ((nextEntry % 4) != 0) {
throw new MonitorStructureException("Entry index not properly aligned: " + nextEntry);
}
// protect against a corrupted shared memory region.
if ((nextEntry < 0) || (nextEntry > buffer.limit())) {
throw new MonitorStructureException(
"Entry index out of bounds: nextEntry = " + nextEntry + ", limit = " + buffer.limit());
}
// check for the end of the buffer
if (nextEntry == buffer.limit()) {
lognl("getNextMonitorEntry():" + " nextEntry == buffer.limit(): returning");
return null;
}
buffer.position(nextEntry);
int entryStart = buffer.position();
int entryLength = buffer.getInt();
// check for valid entry length
if ((entryLength < 0) || (entryLength > buffer.limit())) {
throw new MonitorStructureException("Invalid entry length: entryLength = " + entryLength);
}
// check if last entry occurs before the eof.
if ((entryStart + entryLength) > buffer.limit()) {
throw new MonitorStructureException(
"Entry extends beyond end of buffer: "
+ " entryStart = "
+ entryStart
+ " entryLength = "
+ entryLength
+ " buffer limit = "
+ buffer.limit());
}
if (entryLength == 0) {
// end of data
return null;
}
int nameLength = buffer.getInt();
int vectorLength = buffer.getInt();
byte dataType = buffer.get();
byte flags = buffer.get();
Units u = Units.toUnits(buffer.get());
Variability v = Variability.toVariability(buffer.get());
boolean supported = (flags & 0x01) != 0;
// defend against corrupt entries
if ((nameLength <= 0) || (nameLength > entryLength)) {
throw new MonitorStructureException("Invalid Monitor name length: " + nameLength);
}
if ((vectorLength < 0) || (vectorLength > entryLength)) {
throw new MonitorStructureException("Invalid Monitor vector length: " + vectorLength);
}
// read in the perfData item name, casting bytes to chars. skip the
// null terminator
//
byte[] nameBytes = new byte[nameLength - 1];
for (int i = 0; i < nameLength - 1; i++) {
nameBytes[i] = buffer.get();
}
// convert name into a String
String name = new String(nameBytes, 0, nameLength - 1);
if (v == Variability.INVALID) {
throw new MonitorDataException(
"Invalid variability attribute:" + " entry index = " + perfDataItem + " name = " + name);
}
if (u == Units.INVALID) {
throw new MonitorDataException(
"Invalid units attribute: " + " entry index = " + perfDataItem + " name = " + name);
}
int offset;
if (vectorLength == 0) {
// scalar Types
if (dataType == BasicType.LONG.intValue()) {
offset = entryStart + entryLength - 8; /* 8 = sizeof(long) */
buffer.position(offset);
LongBuffer lb = buffer.asLongBuffer();
lb.limit(1);
monitor = new PerfLongMonitor(name, u, v, supported, lb);
perfDataItem++;
} else {
// bad data types.
throw new MonitorTypeException(
"Invalid Monitor type:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " type = "
+ dataType);
}
} else {
// vector types
if (dataType == BasicType.BYTE.intValue()) {
if (u != Units.STRING) {
// only byte arrays of type STRING are currently supported
throw new MonitorTypeException(
"Invalid Monitor type:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " type = "
+ dataType);
}
offset = entryStart + PERFDATA_NAME_OFFSET + nameLength;
buffer.position(offset);
ByteBuffer bb = buffer.slice();
bb.limit(vectorLength);
bb.position(0);
if (v == Variability.CONSTANT) {
monitor = new PerfStringConstantMonitor(name, supported, bb);
} else if (v == Variability.VARIABLE) {
monitor = new PerfStringVariableMonitor(name, supported, bb, vectorLength - 1);
} else {
// Monotonically increasing byte arrays are not supported
throw new MonitorDataException(
"Invalid variability attribute:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " variability = "
+ v);
}
perfDataItem++;
} else {
// bad data types.
throw new MonitorTypeException(
"Invalid Monitor type:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " type = "
+ dataType);
}
}
// setup index to next entry for next iteration of the loop.
nextEntry = entryStart + entryLength;
return monitor;
}