path: root/qpid/java/management/agent/src/main/java/org/apache/qpid/agent/Agent.java

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.qpid.agent;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.jms.BytesMessage;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.qpid.agent.binding.BindingContext;
import org.apache.qpid.agent.binding.BindingUtils;
import org.apache.qpid.agent.binding.ClassBinding;
import org.apache.qpid.agent.binding.BindingException;
import org.apache.qpid.agent.binding.MethodBinding;
import org.apache.qpid.agent.binding.ParameterBinding;
import org.apache.qpid.agent.binding.PropertyBinding;
import org.apache.qpid.agent.binding.TypeBinding;
import org.apache.qpid.client.AMQConnection;
import org.apache.qpid.transport.codec.BBDecoder;
import org.apache.qpid.transport.codec.BBEncoder;
import org.apache.qpid.transport.codec.Decoder;

/**
 * The main class for interacting with the QMF bus. Objects which are to be
 * managed can be registered with the agent, as can classes to be exposed via
 * the schema.
 */
public class Agent implements MessageListener
{
    // The following are settings to configure the Agent
    protected AMQConnection connection;
    protected boolean sessionTransacted = false;
    protected int acknowledgeMode = Session.AUTO_ACKNOWLEDGE;
    protected String label;
    protected UUID systemId;
    // this list holds the objects until the agent is started
    protected List managedObjects = new ArrayList();
    protected List registeredClasses = new ArrayList();
    // The following instance variables are not
    // able to be set by the end user.
    protected Session session;
    protected MessageProducer prod;
    protected MessageConsumer cons;
    protected Queue reply;
    protected BindingContext bctx = new BindingContext();
    protected Map<Long, ManagedObject> objects = new Hashtable<Long, ManagedObject>();
    protected long bbank;
    protected long abank;
    protected static final Log log = LogFactory.getLog(Agent.class);
    protected volatile boolean inside = false;
    protected ClassLoader classLoader = null;

    public Agent()
    {
        systemId = UUID.randomUUID();
        log.debug(String.format("Agent with uid %s created", systemId
                .toString()));
    }

    public Agent(String label, UUID systemId)
    {
        this.systemId = systemId;
        this.label = label;
        log.debug(String.format("Agent with name %s and uid %s created", label,
                systemId.toString()));
    }

    public void register(ManagedObject managedObject)
    {
        Class managedClass = managedObject.getObjectClass();
        long id = managedObject.getId();
        ClassBinding cb = bctx.register(managedClass);
        managedObject.setManagedClassName(cb.getName());
        managedObject.setManagedPackageName(cb.getPackage());
        log.debug(String.format(
                "Added managed object id '%d' for package '%s' class '%s'", id,
                managedObject.getManagedPackageName(), managedObject
                        .getManagedClassName()));
        objects.put(id, managedObject);
        managedObjects.add(managedObject);
    }

    public void registerClass(Class cls)
    {
        bctx.register(cls);
        if (!registeredClasses.contains(cls))
        {
            registeredClasses.add(cls);
        }
    }

    /**
     * Stops the agents connection to the bus
     */
    public void stop()
    {
        try
        {
            cons.close();
            prod.close();
            connection.stop();
            connection.close();
            session.close();
        } catch (JMSException e)
        {
            log.error("Exception:", e);
        }
    }

    /**
     * Starts up the agent. Many bean containers may call this by default which
     * aids in deployment
     */
    public void start()
    {
        log.debug(String.format("Agent with uid %s and name %s starting",
                systemId.toString(), label));
        for (Object clsName : registeredClasses.toArray())
        {
            try
            {
                Class cls = null;
                if (String.class.isAssignableFrom(clsName.getClass()))
                {
                    cls = getClass(clsName.toString());
                } else
                {
                    cls = (Class) clsName;
                }
                this.registerClass(cls);
            } catch (Exception e)
            {
                log.error("Could not register class " + clsName);
            }
        }
        for (Object obj : managedObjects.toArray())
        {
            this.register((ManagedObject) obj);
        }
        try
        {
            session = connection.createSession(sessionTransacted,
                    acknowledgeMode);
            reply = session
                    .createQueue(String
                            .format(
                                    "direct://amq.direct//%s-%s?exclusive='True'&autodelete='True'",
                                    label, systemId));
            cons = session.createConsumer(reply);
            cons.setMessageListener(this);
            prod = session.createProducer(null);
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
        attachRequest(label, systemId);
        try
        {
            connection.start();
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
    }

    /**
     * Send an event object to the bus
     */
    public void raiseEvent(Object value, EventSeverity sev)
    {
        log.debug(String.format("Sending event of class %s with Severity %s",
                value.getClass(), sev.ordinal()));
        BBEncoder enc = this.init('e');
        ClassBinding cb = bctx.getClassBinding(value.getClass());
        String pkg = cb.getPackage();
        String cls = cb.getName();
        enc.writeStr8(pkg);
        enc.writeStr8(cls);
        enc.writeBin128(cb.getSchemaHash());
        long now = System.currentTimeMillis() * 1000000;
        enc.writeInt64(now);
        enc.writeUint8((short) sev.ordinal());
        for (PropertyBinding p : cb.getProperties())
        {
            p.getType().encode(enc, BindingUtils.get(p, value));
        }
        send(
                String.format("console.event.%d.%d.%s.%s", bbank, abank, pkg,
                        cls), enc);
    }

    public void onMessage(Message message)
    {
        if (inside)
        {
            new Throwable().printStackTrace();
        }
        inside = true;
        Decoder dec = readBody(message);
        Destination replyTo;
        try
        {
            replyTo = message.getJMSReplyTo();
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
        byte[] magic = dec.readBytes(3);
        if (magic[0] != 'A' || magic[1] != 'M' || magic[2] != '2')
        {
            throw new AgentException("bad magic: " + new String(magic));
        }
        short op = dec.readUint8();
        long seq = dec.readUint32();
        log.debug("Message recieved: " + (char) op);
        switch (op)
        {
        case 'a':
            this.handleAgentAttach(seq, replyTo, dec);
            break;
        case 'G':
            this.handleGetQuery(seq, replyTo, dec);
            break;
        case 'M':
            this.handleMethodRequest(seq, replyTo, dec);
            break;
        case 'S':
            this.handleSchemaRequest(seq, replyTo, dec);
            break;
        case 'x':
            // TODO
            break;
        default:
            throw new IllegalArgumentException("opcode: " + ((char) op));
        }
        inside = false;
    }

    protected ClassBinding getClassBinding(ManagedObject mobj)
    {
        return bctx.getClassBinding(mobj.getObjectClass());
    }

    private byte[] ensure(int capacity, byte[] body, int size)
    {
        if (capacity > body.length)
        {
            byte[] copy = new byte[capacity];
            System.arraycopy(body, 0, copy, 0, size);
            body = copy;
        }
        return body;
    }

    private Decoder readBody(Message message)
    {
        BytesMessage msg = (BytesMessage) message;
        BBDecoder dec = new BBDecoder();
        byte[] buf = new byte[1024];
        byte[] body = new byte[1024];
        int size = 0;
        int n;
        try
        {
            while ((n = msg.readBytes(buf)) > 0)
            {
                body = ensure(size + n, body, size);
                System.arraycopy(buf, 0, body, size, n);
                size += n;
            }
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
        dec.init(ByteBuffer.wrap(body, 0, size));
        return dec;
    }

    protected void handleAgentAttach(long seq, Destination replyTo, Decoder dec)
    {
        log.debug("Agent Attach Message");
        bbank = dec.readUint32();
        abank = dec.readUint32();
        try
        {
            MessageConsumer mc = session
                    .createConsumer(session
                            .createQueue(String
                                    .format(
                                            "management://qpid.management//%s-%s?routingkey='agent.%d.%d'&exclusive='True'&autodelete='True'",
                                            label, systemId, bbank, abank)));
            mc.setMessageListener(this);
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
        for (String packageName : bctx.getPackages())
        {
            packageIndication(packageName);
        }
        for (ClassBinding cb : bctx.getAllBindings())
        {
            classIndication(cb);
        }
        for (ManagedObject mo : objects.values())
        {
            content('i', seq, null, mo);
        }
    }

    protected void handleMethodRequest(long seq, Destination replyTo,
            Decoder dec)
    {
        dec.readUint64(); // first part of object-id
        long id = dec.readUint64();
        ManagedObject mo = objects.get(id);
        if (mo == null)
        {
            methodResponse(seq, replyTo, 1, String.format(
                    "no such object: 0x%x", id));
        } else
        {
            dec.readStr8(); // pkg
            dec.readStr8(); // cls
            dec.readBin128(); // hash
            String mname = dec.readStr8();
            ClassBinding cls = getClassBinding(mo);
            MethodBinding method = cls.getMethod(mname);
            if (method == null)
            {
                methodResponse(seq, replyTo, 2, String.format(
                        "no such method: %s", mname));
            } else
            {
                log.trace("Handle method: " + method.getName());
                List<ParameterBinding> params = method.getInParameters();
                Object[] args = new Object[params.size()];
                int idx = 0;
                for (ParameterBinding p : params)
                {
                    TypeBinding typeBinding = p.getType();
                    log
                            .trace(String
                                    .format(
                                            "Decoding parameter with type %s ref package %s ref class %s ",
                                            typeBinding.getCode(), typeBinding
                                                    .getRefPackage(),
                                            typeBinding.getRefClass()));
                    args[idx++] = typeBinding.decode(dec);
                    log.trace("Done");
                }
                try
                {
                    Object[] result = mo.invoke(method, args);
                    methodResponse(seq, replyTo, 0, null, method, result);
                } catch (BindingException ex)
                {
                    log
                            .error(
                                    String
                                            .format(
                                                    "An exception occured invoking method %s. Stack trace sent to console.",
                                                    method.getName()), ex);
                    StringWriter str = new StringWriter();
                    PrintWriter writer = new PrintWriter(str);
                    ex.printStackTrace(writer);
                    writer.flush();
                    methodResponse(seq, replyTo, 7, str.toString());
                }
                log.trace("Done with method: " + method.getName());
            }
        }
    }

    protected void handleGetQuery(long seq, Destination replyTo, Decoder dec)
    {
        Map<String, Object> data = dec.readMap();
        if (data.containsKey("_objectid"))
        {
            long objId = (Long) data.get("_objectid");
            log.debug("Get Request message for object id " + objId);
            ManagedObject mo = objects.get(objId);
            if (mo == null)
            {
                methodResponse(seq, replyTo, 1, String.format(
                        "no such object: 0x%x", objId));
            } else
            {
                content('g', seq, replyTo, mo);
            }
        } else if (data.containsKey("_class"))
        {
            String className = (String) data.get("_class");
            String packageName = (String) data.get("_package");
            log.debug(String.format(
                    "Get Request message for package '%s' class '%s'",
                    packageName, className));
            for (ManagedObject mo : objects.values())
            {
                if (mo.getManagedClassName().equals(className))
                {
                    if ((packageName == null) || packageName.equals("")
                            || packageName.equals(mo.getManagedPackageName()))
                    {
                        content('g', seq, replyTo, mo);
                    }
                }
            }
        } else
        {
            for (ManagedObject mo : objects.values())
            {
                content('g', seq, replyTo, mo);
            }
        }
        complete(seq, replyTo);
    }

    protected void handleSchemaRequest(long seq, Destination replyTo,
            Decoder dec)
    {
        String pkg = dec.readStr8();
        String cls = dec.readStr8();
        log.debug(String.format(
                "SchemaRequest message for package '%s' class '%s'", pkg, cls));
        ClassBinding cb = bctx.getClassBinding(pkg, cls);
        if (cb == null)
        {
            throw new AgentException("no such class: " + pkg + ", " + cls);
        }
        schemaResponse(seq, cb);
    }

    protected BBEncoder init(char opcode)
    {
        return init(opcode, 0);
    }

    protected BBEncoder init(char opcode, long sequence)
    {
        BBEncoder enc = new BBEncoder(1024);
        enc.init();
        enc.writeUint8((short) 'A');
        enc.writeUint8((short) 'M');
        enc.writeUint8((short) '2');
        enc.writeUint8((short) opcode);
        enc.writeUint32(sequence);
        return enc;
    }

    protected void send(BBEncoder enc)
    {
        send("broker", enc);
    }

    protected void send(Destination dest, BBEncoder enc)
    {
        try
        {
            byte[] buf = new byte[1024];
            BytesMessage msg = session.createBytesMessage();
            ByteBuffer slice = enc.segment();
            while (slice.hasRemaining())
            {
                int n = Math.min(buf.length, slice.remaining());
                slice.get(buf, 0, n);
                msg.writeBytes(buf, 0, n);
            }
            msg.setJMSReplyTo(reply);
            // ???: I assume this is thread safe.
            prod.send(dest, msg);
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
    }

    protected void send(String routingKey, BBEncoder enc)
    {
        try
        {
            send(session
                    .createQueue("management://qpid.management//?routingkey='"
                            + routingKey + "'"), enc);
        } catch (JMSException e)
        {
            throw new AgentException(e);
        }
    }

    protected void attachRequest(String label, UUID systemId)
    {
        BBEncoder enc = init('A');
        enc.writeStr8(label);
        enc.writeUuid(systemId);
        enc.writeUint32(0);
        enc.writeUint32(0);
        send(enc);
    }

    protected void packageIndication(String pkg)
    {
        BBEncoder enc = init('p');
        enc.writeStr8(pkg);
        send(enc);
    }

    protected void classIndication(ClassBinding cb)
    {
        BBEncoder enc = init('q');
        enc.writeUint8(cb.getKind());
        enc.writeStr8(cb.getPackage());
        enc.writeStr8(cb.getName());
        enc.writeBin128(cb.getSchemaHash()); // schema hash?
        send(enc);
    }

    protected void schemaResponse(long seq, ClassBinding cb)
    {
        BBEncoder enc = init('s', seq);
        cb.encode(enc);
        send(enc);
    }

    protected void content(char c, long seq, Destination dest, ManagedObject mo)
    {
        BBEncoder enc = init(c, seq);
        ClassBinding cb = getClassBinding(mo);
        String pkg = cb.getPackage();
        String cls = cb.getName();
        enc.writeStr8(pkg);
        enc.writeStr8(cls);
        enc.writeBin128(cb.getSchemaHash());
        long now = System.currentTimeMillis() * 1000000;
        enc.writeUint64(now);
        enc.writeUint64(now);
        enc.writeUint64(0);
        enc.writeUint64(0x0000FFFFFFFFFFFFL & ((bbank << 28) | abank));
        enc.writeUint64(mo.getId());
        for (PropertyBinding p : cb.getProperties())
        {
            p.getType().encode(enc, mo.get(p));
        }
        if (dest == null)
        {
            send(String.format("console.obj.%d.%d.%s.%s", bbank, abank, pkg,
                    cls), enc);
        } else
        {
            send(dest, enc);
        }
    }

    protected void complete(long seq, Destination dest)
    {
        BBEncoder enc = init('z', seq);
        enc.writeUint32(0);
        enc.writeStr8("");
        send(dest, enc);
    }

    protected void methodResponse(long seq, Destination dest, int status,
            String text)
    {
        methodResponse(seq, dest, status, text, null, null);
    }

    protected void methodResponse(long seq, Destination dest, int status,
            String text, MethodBinding method, Object[] result)
    {
        BBEncoder enc = init('m', seq);
        enc.writeUint32(status);
        enc.writeStr16(text == null ? "" : text);
        if (method != null)
        {
            int idx = 0;
            for (ParameterBinding p : method.getOutParameters())
            {
                p.getType().encode(enc, result[idx++]);
            }
        }
        send(dest, enc);
    }

    protected Class getClass(String className)
    {
        try
        {
            if (classLoader != null)
            {
                return classLoader.loadClass(className);
            } else
            {
                return Class.forName(className);
            }
        } catch (ClassNotFoundException e)
        {
            throw new AgentException(String.format(
                    "No class named %s was found", className), e);
        }
    }

    public String getLabel()
    {
        return label;
    }

    public void setLabel(String label)
    {
        this.label = label;
    }

    public AMQConnection getConnection()
    {
        return connection;
    }

    public void setConnection(AMQConnection connection)
    {
        this.connection = connection;
    }

    public boolean isSessionTransacted()
    {
        return sessionTransacted;
    }

    public void setSessionTransacted(boolean sessionTransacted)
    {
        this.sessionTransacted = sessionTransacted;
    }

    public void setManagedObjects(List objectList)
    {
        this.managedObjects = objectList;
    }

    public List getManagedObjects()
    {
        return managedObjects;
    }

    public void setRegisteredClasses(List objectList)
    {
        this.registeredClasses = objectList;
    }

    public List getRegisteredClasses()
    {
        return this.registeredClasses;
    }

    public static void main(String[] args) throws Exception
    {
        String broker = args[0];
        String name = args[1];
        String url = String.format(
                "amqp://guest:guest@/?brokerlist='tcp://%s'", broker);
        AMQConnection conn = new AMQConnection(url);
        Agent agent = new Agent(name, UUID.randomUUID());
        agent.setConnection(conn);
        for (int i = 2; i < args.length; i++)
        {
            Class<?> cls = Class.forName(args[i]);
            agent.register(new ManagedPOJO(cls.newInstance()));
        }
        agent.start();
        while (true)
        {
            Thread.sleep(1000);
        }
    }
}