/**
* encode the current Control Message into a channel buffer
*
* @throws Exception
*/
ChannelBuffer buffer() throws Exception {
ChannelBufferOutputStream bout =
new ChannelBufferOutputStream(ChannelBuffers.directBuffer(encodeLength()));
write(bout);
bout.close();
return bout.buffer();
}
private void sendReply(Channel channel, int checksum) {
ChannelBuffer reply = ChannelBuffers.directBuffer(ByteOrder.LITTLE_ENDIAN, 3);
reply.writeByte(0x02);
reply.writeShort((short) checksum);
if (channel != null) {
channel.write(reply);
}
}
private static void sendResponse(
Channel channel, SocketAddress remoteAddress, long rawId, int index) {
if (channel != null) {
ChannelBuffer response = ChannelBuffers.directBuffer(12);
response.writeShort(0xfe02);
response.writeLong(rawId);
response.writeShort(index);
channel.write(response, remoteAddress);
}
}
private void requestArchive(Channel channel) {
if (lastIndex == 0) {
lastIndex = newIndex;
} else if (newIndex > lastIndex) {
ChannelBuffer request = ChannelBuffers.directBuffer(ByteOrder.LITTLE_ENDIAN, 12);
request.writeShort(MSG_LOG_SYNC);
request.writeShort(4);
request.writeInt((int) lastIndex);
request.writeInt(0);
channel.write(request);
}
}
private ChannelBuffer allocateBigEndianBuffer(int capacity) {
ChannelBuffer slice;
synchronized (bigEndianLock) {
if (preallocatedBigEndianBuffer == null) {
preallocatedBigEndianBuffer =
ChannelBuffers.directBuffer(ByteOrder.BIG_ENDIAN, preallocatedBufferCapacity);
slice = preallocatedBigEndianBuffer.slice(0, capacity);
preallocatedBigEndianBufferPosition = capacity;
} else if (preallocatedBigEndianBuffer.capacity() - preallocatedBigEndianBufferPosition
>= capacity) {
slice = preallocatedBigEndianBuffer.slice(preallocatedBigEndianBufferPosition, capacity);
preallocatedBigEndianBufferPosition += capacity;
} else {
preallocatedBigEndianBuffer =
ChannelBuffers.directBuffer(ByteOrder.BIG_ENDIAN, preallocatedBufferCapacity);
slice = preallocatedBigEndianBuffer.slice(0, capacity);
preallocatedBigEndianBufferPosition = capacity;
}
}
return slice;
}
private void sendReply(Channel channel, ChannelBuffer data) {
ChannelBuffer header = ChannelBuffers.directBuffer(ByteOrder.LITTLE_ENDIAN, 16);
header.writeBytes(ChannelBuffers.copiedBuffer(ByteOrder.LITTLE_ENDIAN, prefix, CHARSET));
header.writeInt((int) deviceUniqueId);
header.writeInt((int) serverId);
header.writeShort(data.readableBytes());
header.writeByte(checksum(data));
header.writeByte(checksum(header));
if (channel != null) {
channel.write(ChannelBuffers.copiedBuffer(header, data));
}
}
/** create a buffer containing the encoding of this batch */
ChannelBuffer buffer() throws Exception {
ChannelBufferOutputStream bout =
new ChannelBufferOutputStream(ChannelBuffers.directBuffer(encoded_length));
for (TaskMessage msg : msgs) {
writeTaskMessage(bout, msg);
}
// add a END_OF_BATCH indicator
ControlMessage.EOB_MESSAGE.write(bout);
bout.close();
return bout.buffer();
}
/**
* Sends the available MBeanServer domains in this JVM through the passed channel to the passed
* remote address in response to a {@link OpCode#JMX_MBS_INQUIRY} request.
*
* @param channel The channel to write to
* @param remoteAddress The remote address to send to
*/
public static void sendMBeanServerDomains(Channel channel, SocketAddress remoteAddress) {
String[] domains = getMBeanServerDomains();
int size = 4 + (domains.length * 4) + 1;
for (String s : domains) {
size += s.getBytes().length;
}
ChannelBuffer cb = ChannelBuffers.directBuffer(size);
cb.writeByte(OpCode.JMX_MBS_INQUIRY_RESPONSE.op());
cb.writeInt(domains.length);
for (String s : domains) {
byte[] bytes = s.getBytes();
cb.writeInt(bytes.length);
cb.writeBytes(bytes);
}
SimpleLogger.info("Sending MBeanServer Domain List ", Arrays.toString(domains));
channel.write(cb, remoteAddress);
}
/** 假定js都是只读的，如有更新必然体现在文件名上标记版本。 */
public void tryReloadJs() {
if (System.currentTimeMillis() - lastReloadTime < jsReloadPeriodMs) {
return;
}
lastReloadTime = System.currentTimeMillis();
Map<String, ChannelBuffer> newBufferMap = null; // = new HashMap<String, ChannelBuffer>();
for (File f : new File(confAdmin.getFullPathRelatedToConfRoot("js")).listFiles()) {
String name = f.getName();
if (name.endsWith(".js")) {
if (jsBufferMap.containsKey(name)) {
continue;
}
if (newBufferMap == null) {
newBufferMap = new HashMap<String, ChannelBuffer>(jsBufferMap);
}
// TODO: use new io
InputStream in = null;
try {
in = new FileInputStream(f);
ByteArrayOutputStream bao = new ByteArrayOutputStream();
GZIPOutputStreamEx gzo = new GZIPOutputStreamEx(bao, Deflater.BEST_COMPRESSION);
gzo.write(trackUrlExpBa);
byte[] buf = new byte[1024];
int c = 0;
while ((c = in.read(buf)) != -1) {
gzo.write(buf, 0, c);
}
gzo.close();
in.close();
byte[] ba = bao.toByteArray();
ChannelBuffer cbuf = ChannelBuffers.directBuffer(ba.length);
cbuf.writeBytes(ba);
newBufferMap.put(name, cbuf);
} catch (IOException e) { // never happen
log.error(e);
}
}
}
if (newBufferMap != null) {
jsBufferMap = newBufferMap;
}
}
/**
* Writes a notification back to the originating listener registrar
*
* @param channel The channel to write on
* @param remoteAddress The remote address to write to
* @param requestId The request ID of the original listener registration
* @param notification The notification to write
* @param handback The optional contextual handback
*/
public static void writeNotification(
Channel channel,
SocketAddress remoteAddress,
int requestId,
Notification notification,
Object handback) {
byte[] payload = getOutput(notification, handback);
int size =
payload.length
+ 1
+ 4
+ 4; // size is <payload size> + <OpCode> + <requestId> + <<payload length>
ChannelBuffer cb = ChannelBuffers.directBuffer(size);
cb.writeByte(OpCode.JMX_NOTIFICATION.op());
cb.writeInt(requestId);
cb.writeInt(payload.length);
cb.writeBytes(payload);
channel.write(cb, remoteAddress);
SimpleLogger.info("Wrote JMX Notification [", size, "] bytes");
}
public ChannelBuffer getBuffer(ByteOrder order, int capacity) {
if (order == null) {
throw new NullPointerException("order");
}
if (capacity < 0) {
throw new IllegalArgumentException("capacity: " + capacity);
}
if (capacity == 0) {
return ChannelBuffers.EMPTY_BUFFER;
}
if (capacity >= preallocatedBufferCapacity) {
return ChannelBuffers.directBuffer(order, capacity);
}
ChannelBuffer slice;
if (order == ByteOrder.BIG_ENDIAN) {
slice = allocateBigEndianBuffer(capacity);
} else {
slice = allocateLittleEndianBuffer(capacity);
}
slice.clear();
return slice;
}
/**
* Writes a JMX invocation response back to the caller
*
* @param requestId The original request id
* @param methodId The {@link MBeanServerConnection} method ID byte
* @param channel The channel to write to
* @param remoteAddress The remote address that the channel will write to
* @param response AN array of object responses
*/
public static void writeJMXResponse(
int requestId,
byte methodId,
Channel channel,
SocketAddress remoteAddress,
Object... response) {
byte[] payload = getOutput(response);
int size =
payload.length
+ 1
+ 4
+ 1
+ 4; // size is <payload size> + <OpCode> + <requestId> + <method ID byte> + <payload
// length>
ChannelBuffer cb = ChannelBuffers.directBuffer(size);
cb.writeByte(OpCode.JMX_RESPONSE.op());
cb.writeInt(requestId);
cb.writeByte(methodId);
cb.writeInt(payload.length);
cb.writeBytes(payload);
channel.write(cb, remoteAddress);
SimpleLogger.info("Wrote JMX Response [", size, "] bytes");
}
private void sendReply(Channel channel, long deviceId, byte packetNumber) {
ChannelBuffer reply = ChannelBuffers.directBuffer(ByteOrder.LITTLE_ENDIAN, 28);
reply.writeByte('M');
reply.writeByte('C');
reply.writeByte('G');
reply.writeByte('P');
reply.writeByte(MSG_SERVER_ACKNOWLEDGE);
reply.writeInt((int) deviceId);
reply.writeByte(commandCount++);
reply.writeInt(0); // authentication code
reply.writeByte(0);
reply.writeByte(packetNumber);
reply.writeZero(11);
byte checksum = 0;
for (int i = 4; i < 27; i++) {
checksum += reply.getByte(i);
}
reply.writeByte(checksum);
if (channel != null) {
channel.write(reply);
}
}
/**
* {@inheritDoc}
*
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method,
* java.lang.Object[])
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (MBeanServerConnection.class != method.getDeclaringClass()) {
return method.invoke(Modifier.isStatic(method.getModifiers()) ? null : this, args);
}
if (channel.getPipeline().get(getClass().getSimpleName()) == null) {
throw new IOException("This MBeanServerConnection has been closed", new Throwable());
}
// SimpleLogger.debug("MBeanServerConnection [", method.getName(), "] Payload Size [",
// sargs.length+6+4, "]");
final int reqId = requestId.incrementAndGet();
if ("addNotificationListener".equals(method.getName())
&& !method.getParameterTypes()[1].equals(ObjectName.class)) {
NotificationListener listener = (NotificationListener) args[1];
args[1] = reqId;
addRegisteredListener(reqId, listener);
} else if ("removeNotificationListener".equals(method.getName())
&& !method.getParameterTypes()[1].equals(ObjectName.class)) {
removeRegisteredListener((NotificationListener) args[1]);
args = new Object[0];
}
byte[] sargs = getOutput(args);
ChannelBuffer cb =
ChannelBuffers.directBuffer(1 + domainInfoData.length + 4 + 1 + 4 + sargs.length);
cb.writeByte(OpCode.JMX_REQUEST.op()); // 1
cb.writeBytes(domainInfoData); // domain data
cb.writeInt(reqId); // 4
cb.writeByte(methodToKey.get(method)); // 1
cb.writeInt(sargs.length); // 4
cb.writeBytes(sargs); // sargs.length
if (listener == null) {
synchTimeoutMap.addListener(
new TimeoutListener<Integer, CountDownLatch>() {
@Override
public void onTimeout(Integer key, CountDownLatch value) {
if (reqId == key) {
synchTimeoutMap.remove(key);
synchTimeoutMap.removeListener(this);
onSynchronousResponse(
reqId,
new IOException(
"Operation timed out after [" + timeout + "] ms.", new Throwable()));
}
}
});
} else {
asynchTimeoutMap.put(reqId, listener, timeout);
asynchTimeoutMap.addListener(
new TimeoutListener<Integer, AsynchJMXResponseListener>() {
@Override
public void onTimeout(Integer key, AsynchJMXResponseListener value) {
if (reqId == key) {
asynchTimeoutMap.remove(key);
listener.onTimeout(reqId, timeout);
asynchTimeoutMap.removeListener(this);
}
}
});
}
channel
.write(cb, remoteAddress)
.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isSuccess()) {
SimpleLogger.debug("Sent JMX Request to [", remoteAddress, "]");
} else {
SimpleLogger.error(
"Failed to send JMX Request to [", remoteAddress, "]", future.getCause());
}
}
});
if (listener == null) {
waitForSynchronousResponse(reqId, timeout);
Object result = synchResultMap.get(reqId);
if (result != null && result instanceof Throwable) {
throw (Throwable) result;
}
return result;
}
return null;
}