* JBoss, Home of Professional Open Source.

* Copyright 2012, Red Hat, Inc., and individual contributors

* as indicated by the @author tags. See the copyright.txt file in the

* distribution for a full listing of individual contributors.

*

* This is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1 of

* the License, or (at your option) any later version.

*

* This software is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this software; if not, write to the Free

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA, or see the FSF site: http://www.fsf.org.

*/

* The VersionOne client connection.

*

* @author <a href="mailto:darran.lofthouse@jboss.com">Darran Lofthouse</a>

*/

    private static final String REMOTING_JMX = "remoting-jmx";

    private static final String CLIENT_THREAD = "client-thread-";

    public static final int DEFAULT_TIMEOUT = 60;

    private static final Logger log = Logger.getLogger(ClientConnection.class);

    private final Channel channel;

    // Registry of handlers for the incoming messages.

    private final Map<Byte, Common.MessageHandler> handlerRegistry;

    private boolean manageExecutor = false;

    private final Executor executor;

    private final int timeoutSeconds;

    private String connectionId;

    private TheConnection mbeanServerConnection;

    private LocalNotificationManager localNotificationManager;

    private int nextCorrelationId = 1;

    /**

     * The in-progress requests awaiting a response.

     */

    private final Map<Integer, VersionedIoFuture> requests = new HashMap<Integer, VersionedIoFuture>();

    ClientConnection(final Channel channel, final Map<String, ?> environment) {

        super(channel);

        this.channel = channel;

        handlerRegistry = createHandlerRegistry();

        Integer seconds = null;

        if (environment != null && environment.containsKey(TIMEOUT_KEY)) {

            final Object timeout = environment.get(TIMEOUT_KEY);

            if (timeout instanceof Number) {

                seconds = ((Number) timeout).intValue();

            } else if (timeout instanceof String) {

                try {

                    seconds = Integer.parseInt((String) timeout);

                } catch (NumberFormatException e) {

                    log.warnf(e, "Could not parse configured timeout %s", timeout);

                }

            } else {

                log.warnf("Timeout %s configured via environment is not valid ", timeout);

            }

        } else {

            seconds = Integer.getInteger(TIMEOUT_KEY, DEFAULT_TIMEOUT);

        }

        if (environment != null && environment.containsKey(Executor.class.getName())) {

            executor = (Executor) environment.get(Executor.class.getName());

        } else {

            executor = Executors.newCachedThreadPool(new ThreadFactory() {

                final ThreadGroup group = new ThreadGroup(REMOTING_JMX);

                final AtomicInteger threadNumber = new AtomicInteger(1);

                public Thread newThread(Runnable r) {

                    return new Thread(group, r, REMOTING_JMX + " " + CLIENT_THREAD + threadNumber.getAndIncrement());

                }

            });

            manageExecutor = true;

        }

        timeoutSeconds = seconds == null ? DEFAULT_TIMEOUT : seconds;

    }

    private Map<Byte, Common.MessageHandler> createHandlerRegistry() {

        Map<Byte, Common.MessageHandler> registry = new HashMap<Byte, Common.MessageHandler>();

        registry.put((byte) (ADD_NOTIFICATION_LISTENER ^ RESPONSE_MASK), new MarshalledResponseHandler<Void>(VOID));

        registry.put((byte) (CREATE_MBEAN ^ RESPONSE_MASK), new MarshalledResponseHandler<ObjectInstance>(OBJECT_INSTANCE));

        registry.put((byte) (GET_ATTRIBUTE ^ RESPONSE_MASK), new MarshalledResponseHandler<Object>(OBJECT));

        registry.put((byte) (GET_ATTRIBUTES ^ RESPONSE_MASK), new MarshalledResponseHandler<AttributeList>(ATTRIBUTE_LIST));

        registry.put((byte) (GET_DEFAULT_DOMAIN ^ RESPONSE_MASK), new StringResponseHandler());

        registry.put((byte) (GET_DOMAINS ^ RESPONSE_MASK), new StringArrayResponseHandler());

        registry.put((byte) (GET_MBEAN_COUNT ^ RESPONSE_MASK), new IntegerResponseHandler());

        registry.put((byte) (GET_MBEAN_INFO ^ RESPONSE_MASK), new MarshalledResponseHandler<MBeanInfo>(MBEAN_INFO));

        registry.put((byte) (GET_OBJECT_INSTANCE ^ RESPONSE_MASK), new MarshalledResponseHandler<ObjectInstance>(

                OBJECT_INSTANCE));

        registry.put((byte) (INSTANCE_OF ^ RESPONSE_MASK), new BooleanResponseHandler());

        registry.put((byte) (IS_REGISTERED ^ RESPONSE_MASK), new BooleanResponseHandler());

        registry.put((byte) (INVOKE ^ RESPONSE_MASK), new MarshalledResponseHandler<Object>(OBJECT));

        registry.put((byte) (QUERY_MBEANS ^ RESPONSE_MASK), new MarshalledResponseHandler<Set<ObjectInstance>>(

                SET_OBJECT_INSTANCE));

        registry.put((byte) (QUERY_NAMES ^ RESPONSE_MASK), new MarshalledResponseHandler<Set<ObjectName>>(SET_OBJECT_NAME));

        registry.put((byte) (REMOVE_NOTIFICATION_LISTENER ^ RESPONSE_MASK), new MarshalledResponseHandler<Void>(VOID));

        registry.put((byte) (SET_ATTRIBUTE ^ RESPONSE_MASK), new MarshalledResponseHandler<Void>(VOID));

        registry.put((byte) (SET_ATTRIBUTES ^ RESPONSE_MASK), new MarshalledResponseHandler<AttributeList>(ATTRIBUTE_LIST));

        registry.put((byte) (UNREGISTER_MBEAN ^ RESPONSE_MASK), new MarshalledResponseHandler<Void>(VOID));

        registry.put(SEND_NOTIFICATION, new NotificationHandler());

        return Collections.unmodifiableMap(registry);

    }

    void start() throws IOException {

        sendVersionHeader();

        IoFuture<String> futureConnectionId = ConnectionIdReceiver.getConnectionId(channel);

        IoFuture.Status result = futureConnectionId.await(timeoutSeconds, TimeUnit.SECONDS);

        switch (result) {

            case DONE:

                connectionId = futureConnectionId.get();

                mbeanServerConnection = new TheConnection();

                localNotificationManager = new LocalNotificationManager();

                channel.receiveMessage(new MessageReceiver());

                break;

            case FAILED:

                throw futureConnectionId.getException();

            default:

                throw new IOException("Unable to obtain connectionId, status=" + result.toString());

        }

    }

    private void sendVersionHeader() throws IOException {

        write(new MessageWriter() {

            @Override

            public void write(DataOutput output) throws IOException {

                output.writeBytes("JMX");

                output.writeByte(VersionOne.getVersionIdentifier());

            }

        });

    }

    public String getConnectionId() {

        if (connectionId == null) {

            throw new IllegalStateException("Connection ID not set");

        }

        return connectionId;

    }

    public MBeanServerConnection getMBeanServerConnection(Subject subject) {

        if (subject != null) {

            throw new UnsupportedOperationException("Subject delegation not supported for getMBeanServerConnection");

        }

        // It is normal for only a single instance of MBeanServerConnection to be used.

        return mbeanServerConnection;

    }

    public void close() {

        if (manageExecutor && executor instanceof ExecutorService) {

            ((ExecutorService) executor).shutdown();

        }

    }

    /**

     * Get the next correlation ID, returning to the beginning once all integers have been used.

     * <p/>

     * THIS METHOD IS NOT TO BE USED DIRECTLY WHERE A CORRELATION ID NEEDS TO BE RESERVED.

     *

     * @return The next correlationId.

     */

    private synchronized int getNextCorrelationId() {

        int next = nextCorrelationId++;

        // After the maximum integer start back at the beginning.

        if (next < 0) {

            nextCorrelationId = 2;

            next = 1;

        }

        return next;

    }

    /**

     * Reserves a correlation ID by taking the next value and ensuring it is stored in the Map.

     *

     * @return the next reserved correlation ID

     */

    private synchronized int reserveNextCorrelationId(VersionedIoFuture future) {

        Integer next = getNextCorrelationId();

        // Not likely but possible to use all IDs and start back at beginning while

        // old request still in progress.

        while (requests.containsKey(next)) {

            next = getNextCorrelationId();

        }

        requests.put(next, future);

        return next;

    }

    private synchronized <T> VersionedIoFuture<T> getFuture(int correlationId) {

        // TODO - How to check this?

        return requests.get(correlationId);

    }

    private synchronized void releaseCorrelationId(int correlationId) {

        // TODO - Will maybe move to not removing by default and timeout failed requests.

        requests.remove(correlationId);

    }

    private synchronized void cancelAllRequests(final IOException io) {

        for (VersionedIoFuture current : requests.values()) {

            current.setException(io);

        }

        requests.clear();

    }

    /**

     * The local management of notifications.

     */

    private class LocalNotificationManager {

        private int nextNotificationId = 1;

        private Map<Integer, Association> listeners = new HashMap<Integer, ClientConnection.LocalNotificationManager.Association>();

        private synchronized int getNextNotificationId() {

            int next = nextNotificationId++;

            // After the maximum integer start back at the beginning.

            if (next < 0) {

                nextNotificationId = 2;

                next = 1;

            }

            return next;

        }

        private synchronized int associate(ObjectName target, NotificationListener listener, NotificationFilter filter,

                Object handBack) {

            Integer next = getNextNotificationId();

            // Not likely but possible to use all IDs and start back at beginning while

            // old request still in progress.

            while (listeners.containsKey(next)) {

                next = getNextNotificationId();

            }

            Association association = new Association();

            association.target = target;

            association.listener = listener;

            association.filter = filter;

            association.handBack = handBack;

            listeners.put(next, association);

            return next;

        }

        private synchronized void cancel(int id) {

            listeners.remove(id);

        }

        private synchronized Association get(int id) {

            return listeners.get(id);

        }

        /*

         * The message received will already be being processed on a Thread obtained from the local Executor, for this reason

         * there is no point in creating a new Runnable and passing it to the executor to process the Notification.

         */

        private void notify(int id, Notification n, Object handback) {

            Association association = get(id);

            if (association != null) {

                association.listener.handleNotification(n, handback);

            } else {

                // If an invalid ID is received don't throw an error, instead just send

                // a message to the server canceling the notification by id.

                try {

                    log.warnf("Notification recieved for non existant NotificationListener %d", id);

                    mbeanServerConnection.removeNotificationListener(new int[] { id });

                } catch (InstanceNotFoundException e) {

                } catch (ListenerNotFoundException e) {

                } catch (IOException e) {

                }

            }

        }

        private synchronized int[] matchToRemove(ObjectName name, NotificationListener listener) {

            List<Integer> toRemove = new ArrayList<Integer>();

            for (Integer current : listeners.keySet()) {

                Association association = listeners.get(current);

                if ((name == association.target || name.equals(association.target) && listener == association.listener)) {

                    toRemove.add(current);

                }

            }

            int[] response = new int[toRemove.size()];

            for (int i = 0; i < response.length; i++) {

                response[i] = toRemove.get(i);

                listeners.remove(response[i]);

            }

            return response;

        }

        private synchronized int[] matchToRemove(ObjectName name, NotificationListener listener, NotificationFilter filter,

                Object handback) {

            List<Integer> toRemove = new ArrayList<Integer>();

            for (Integer current : listeners.keySet()) {

                Association association = listeners.get(current);

                if ((name == association.target || name.equals(association.target)) && listener == association.listener

                        && filter == association.filter && handback == association.handBack) {

                    toRemove.add(current);

                }

            }

            int[] response = new int[toRemove.size()];

            for (int i = 0; i < response.length; i++) {

                response[i] = toRemove.get(i);

                listeners.remove(response[i]);

            }

            return response;

        }

        private class Association {

            private ObjectName target;

            private NotificationListener listener;

            private NotificationFilter filter;

            private Object handBack;

        }

    }

    private class MessageReceiver implements Channel.Receiver {

        @Override

        public void handleMessage(Channel channel, MessageInputStream message) {

            final DataInputStream dis = new DataInputStream(message);

            try {

                byte messageId = dis.readByte();

                final int correlationId = dis.readInt();

                log.tracef("Message Received id(%h), correlationId(%d)", messageId, correlationId);

                final Common.MessageHandler mh = handlerRegistry.get(messageId);

                if (mh != null) {

                    executor.execute(new Runnable() {

                        @Override

                        public void run() {

                            try {

                                mh.handle(dis, correlationId);

                            } catch (IOException e) {

                                log.error(e);

                            } finally {

                                IoUtils.safeClose(dis);

                            }

                        }

                    });

                } else {

                    throw new IOException("Unrecognised Message ID");

                }

            } catch (IOException e) {

                log.error(e);

                IoUtils.safeClose(dis);

            } finally {

                // TODO - Proper shut down logic.

                channel.receiveMessage(this);

            }

        }

        public void handleError(Channel channel, IOException error) {

            cancelAllRequests(error);

        }

        public void handleEnd(Channel channel) {

            cancelAllRequests(new IOException("Connection Ended"));

        }

    }

    private class TheConnection implements RemotingMBeanServerConnection {

        public Connection getConnection() {

            return channel.getConnection();

        }

        // TODO - Consider a proxy so the specific methods only need to marshall their specific

        // portion of the protocol.

        public ObjectInstance createMBean(final String className, final ObjectName name) throws ReflectionException,

                InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException,

                IOException {

            VersionedIoFuture<TypeExceptionHolder<ObjectInstance>> future = new VersionedIoFuture<TypeExceptionHolder<ObjectInstance>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(CREATE_MBEAN);

                        output.writeInt(correlationId);

                        output.writeByte(INTEGER);

                        output.writeInt(2); // Sending 2 parameters.

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeByte(STRING);

                        marshaller.writeUTF(className);

                        marshaller.writeByte(OBJECT_NAME);

                        marshaller.writeObject(name);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] createMBean - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<ObjectInstance> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        reflectionException(response.e);

                        instanceAlreadyExistsException(response.e);

                        mbeanRegistrationException(response.e);

                        mbeanException(response.e);

                        notCompliantMBeanException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to obtain createMBean, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public ObjectInstance createMBean(final String className, final ObjectName name, final ObjectName loaderName)

                throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException,

                NotCompliantMBeanException, InstanceNotFoundException, IOException {

            VersionedIoFuture<TypeExceptionHolder<ObjectInstance>> future = new VersionedIoFuture<TypeExceptionHolder<ObjectInstance>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(CREATE_MBEAN);

                        output.writeInt(correlationId);

                        output.writeByte(INTEGER);

                        output.writeInt(3); // Sending 3 parameters.

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeByte(STRING);

                        marshaller.writeUTF(className);

                        marshaller.writeByte(OBJECT_NAME);

                        marshaller.writeObject(name);

                        marshaller.writeByte(OBJECT_NAME);

                        marshaller.writeObject(loaderName);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] createMBean - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<ObjectInstance> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        reflectionException(response.e);

                        instanceAlreadyExistsException(response.e);

                        mbeanRegistrationException(response.e);

                        mbeanException(response.e);

                        notCompliantMBeanException(response.e);

                        instanceNotFoundException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to obtain isRegistered, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public ObjectInstance createMBean(final String className, final ObjectName name, final Object[] params,

                final String[] signature) throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException, NotCompliantMBeanException, IOException {

            VersionedIoFuture<TypeExceptionHolder<ObjectInstance>> future = new VersionedIoFuture<TypeExceptionHolder<ObjectInstance>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(CREATE_MBEAN);

                        output.writeInt(correlationId);

                        output.writeByte(INTEGER);

                        output.writeInt(4); // Sending 4 parameters.

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeByte(STRING);

                        marshaller.writeUTF(className);

                        marshaller.writeByte(OBJECT_NAME);

                        marshaller.writeObject(name);

                        marshaller.writeByte(OBJECT_ARRAY);

                        marshaller.writeInt(params.length);

                        for (Object current : params) {

                            marshaller.writeObject(current);

                        }

                        marshaller.writeByte(STRING_ARRAY);

                        marshaller.writeInt(signature.length);

                        for (String current : signature) {

                            marshaller.writeUTF(current);

                        }

                        marshaller.close();

                    }

                });

                log.tracef("[%d] createMBean - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<ObjectInstance> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        reflectionException(response.e);

                        instanceAlreadyExistsException(response.e);

                        mbeanRegistrationException(response.e);

                        mbeanException(response.e);

                        notCompliantMBeanException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to invoke createMBean, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public ObjectInstance createMBean(final String className, final ObjectName name, final ObjectName loaderName,

                final Object[] params, final String[] signature) throws ReflectionException, InstanceAlreadyExistsException,

                MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException, IOException {

            VersionedIoFuture<TypeExceptionHolder<ObjectInstance>> future = new VersionedIoFuture<TypeExceptionHolder<ObjectInstance>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(CREATE_MBEAN);

                        output.writeInt(correlationId);

                        output.writeByte(INTEGER);

                        output.writeInt(5); // Sending 5 parameters.

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeByte(STRING);

                        marshaller.writeUTF(className);

                        marshaller.writeByte(OBJECT_NAME);

                        marshaller.writeObject(name);

                        marshaller.writeByte(OBJECT_NAME);

                        marshaller.writeObject(loaderName);

                        marshaller.writeByte(OBJECT_ARRAY);

                        marshaller.writeInt(params.length);

                        for (Object current : params) {

                            marshaller.writeObject(current);

                        }

                        marshaller.writeByte(STRING_ARRAY);

                        marshaller.writeInt(signature.length);

                        for (String current : signature) {

                            marshaller.writeUTF(current);

                        }

                        marshaller.close();

                    }

                });

                log.tracef("[%d] createMBean - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<ObjectInstance> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        reflectionException(response.e);

                        instanceAlreadyExistsException(response.e);

                        mbeanRegistrationException(response.e);

                        mbeanException(response.e);

                        notCompliantMBeanException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to invoke createMBean, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public void unregisterMBean(final ObjectName name) throws InstanceNotFoundException, MBeanRegistrationException,

                IOException {

            VersionedIoFuture<TypeExceptionHolder<Void>> future = new VersionedIoFuture<TypeExceptionHolder<Void>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(UNREGISTER_MBEAN);

                        output.writeInt(correlationId);

                        output.writeByte(OBJECT_NAME);

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeObject(name);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] unregisterMBean - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<Void> response = future.get();

                        if (response.e == null) {

                            return;

                        }

                        instanceNotFoundException(response.e);

                        mbeanRegistrationException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to invoke unregisterMBean, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public ObjectInstance getObjectInstance(final ObjectName name) throws InstanceNotFoundException, IOException {

            VersionedIoFuture<TypeExceptionHolder<ObjectInstance>> future = new VersionedIoFuture<TypeExceptionHolder<ObjectInstance>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(GET_OBJECT_INSTANCE);

                        output.writeInt(correlationId);

                        output.writeByte(OBJECT_NAME);

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeObject(name);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] getObjectInstance - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<ObjectInstance> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        instanceNotFoundException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to invoke getObjectInstance, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public Set<ObjectInstance> queryMBeans(final ObjectName name, final QueryExp query) throws IOException {

            VersionedIoFuture<TypeExceptionHolder<Set<ObjectInstance>>> future = new VersionedIoFuture<TypeExceptionHolder<Set<ObjectInstance>>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(QUERY_MBEANS);

                        output.writeInt(correlationId);

                        output.writeByte(OBJECT_NAME);

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeObject(name);

                        marshaller.writeByte(QUERY_EXP);

                        marshaller.writeObject(query);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] queryMBeans - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<Set<ObjectInstance>> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to invoke queryMBeans, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public Set<ObjectName> queryNames(final ObjectName name, final QueryExp query) throws IOException {

            VersionedIoFuture<TypeExceptionHolder<Set<ObjectName>>> future = new VersionedIoFuture<TypeExceptionHolder<Set<ObjectName>>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(QUERY_NAMES);

                        output.writeInt(correlationId);

                        output.writeByte(OBJECT_NAME);

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeObject(name);

                        marshaller.writeByte(QUERY_EXP);

                        marshaller.writeObject(query);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] queryNames - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<Set<ObjectName>> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to obtain isRegistered, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public boolean isRegistered(final ObjectName name) throws IOException {

            VersionedIoFuture<TypeExceptionHolder<Boolean>> future = new VersionedIoFuture<TypeExceptionHolder<Boolean>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(IS_REGISTERED);

                        output.writeInt(correlationId);

                        output.writeByte(OBJECT_NAME);

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeObject(name);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] isRegistered - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case DONE:

                        TypeExceptionHolder<Boolean> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        throw toIoException(response.e);

                    case FAILED:

                        throw future.getException();

                    default:

                        throw new IOException("Unable to obtain isRegistered, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public Integer getMBeanCount() throws IOException {

            VersionedIoFuture<TypeExceptionHolder<Integer>> future = new VersionedIoFuture<TypeExceptionHolder<Integer>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(GET_MBEAN_COUNT);

                        output.writeInt(correlationId);

                    }

                });

                log.tracef("[%d] getMBeanCount - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case DONE:

                        TypeExceptionHolder<Integer> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        throw toIoException(response.e);

                    case FAILED:

                        throw future.getException();

                    default:

                        throw new IOException("Unable to obtain MBeanCount, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }

        public Object getAttribute(final ObjectName name, final String attribute) throws MBeanException,

                AttributeNotFoundException, InstanceNotFoundException, ReflectionException, IOException {

            VersionedIoFuture<TypeExceptionHolder<Object>> future = new VersionedIoFuture<TypeExceptionHolder<Object>>();

            final int correlationId = reserveNextCorrelationId(future);

            try {

                write(new MessageWriter() {

                    @Override

                    public void write(DataOutput output) throws IOException {

                        output.writeByte(GET_ATTRIBUTE);

                        output.writeInt(correlationId);

                        output.writeByte(OBJECT_NAME);

                        Marshaller marshaller = prepareForMarshalling(output);

                        marshaller.writeObject(name);

                        marshaller.writeByte(STRING);

                        marshaller.writeUTF(attribute);

                        marshaller.close();

                    }

                });

                log.tracef("[%d] getAttribute - Request Sent", correlationId);

                IoFuture.Status result = future.await(timeoutSeconds, TimeUnit.SECONDS);

                switch (result) {

                    case FAILED:

                        throw future.getException();

                    case DONE:

                        TypeExceptionHolder<Object> response = future.get();

                        if (response.e == null) {

                            return response.value;

                        }

                        mbeanException(response.e);

                        attributeNotFoundException(response.e);

                        instanceNotFoundException(response.e);

                        reflectionException(response.e);

                        throw toIoException(response.e);

                    default:

                        throw new IOException("Unable to obtain isRegistered, status=" + result.toString());

                }

            } finally {

                releaseCorrelationId(correlationId);

            }

        }