Examples with Handle org.apache.qpid.qmf2.common.Handle used on opensource projects

Example 6 with Handle

use of org.apache.qpid.qmf2.common.Handle in project qpid by apache.

the class Console method invokeMethod.

/**
 * Invoke the named method on the named Agent.
 * <p>
 * Intended to by called by the AgentProxy. Shouldn't generally be called directly by Console applications.
 *
 * @param agent the Agent to invoke the method on.
 * @param content an unordered set of key/value pairs comprising the method arguments.
 * @param replyHandle the correlation handle used to tie asynchronous method requests with responses
 * @param timeout the time to wait for a reply from the Agent, a value of -1 means use the default timeout
 * @return the method response Arguments in Map form
 */
public MethodResult invokeMethod(final Agent agent, final Map<String, Object> content, final String replyHandle, int timeout) throws QmfException {
    if (!agent.isActive()) {
        throw new QmfException("Called invokeMethod() with inactive agent");
    }
    String agentName = agent.getName();
    timeout = (timeout < 1) ? _replyTimeout : timeout;
    try {
        Destination destination = (replyHandle == null) ? _replyAddress : _asyncReplyAddress;
        MapMessage request = _syncSession.createMapMessage();
        request.setJMSReplyTo(destination);
        request.setJMSCorrelationID(replyHandle);
        request.setStringProperty("x-amqp-0-10.app-id", "qmf2");
        request.setStringProperty("method", "request");
        request.setStringProperty("qmf.opcode", "_method_request");
        request.setStringProperty("qpid.subject", agentName);
        for (Map.Entry<String, Object> entry : content.entrySet()) {
            request.setObject(entry.getKey(), entry.getValue());
        }
        // it would be somewhat unfortunate if their response got interleaved with ours!!
        synchronized (this) {
            _requester.send(request);
            if (replyHandle == null) {
                // If this is a synchronous request get the response
                Message response = _responder.receive(timeout * 1000);
                if (response == null) {
                    _log.info("No response received in invokeMethod()");
                    throw new QmfException("No response received for Console.invokeMethod()");
                }
                MethodResult result = new MethodResult(AMQPMessage.getMap(response));
                QmfException exception = result.getQmfException();
                if (exception != null) {
                    throw exception;
                }
                return result;
            }
        }
        // If this is an asynchronous request return without waiting for a response
        return null;
    } catch (JMSException jmse) {
        _log.info("JMSException {} caught in invokeMethod()", jmse.getMessage());
        throw new QmfException(jmse.getMessage());
    }
}

Example 7 with Handle

use of org.apache.qpid.qmf2.common.Handle in project qpid by apache.

the class Console method onMessage.

/**
 * MessageListener for QMF2 Agent Events, Hearbeats and Asynchronous data indications
 *
 * @param message the JMS Message passed to the listener
 */
public void onMessage(Message message) {
    try {
        String agentName = QmfData.getString(message.getObjectProperty("qmf.agent"));
        String content = QmfData.getString(message.getObjectProperty("qmf.content"));
        String opcode = QmfData.getString(message.getObjectProperty("qmf.opcode"));
        if (opcode.equals("_agent_heartbeat_indication") || opcode.equals("_agent_locate_response")) {
            // This block handles Agent lifecycle information (discover, register, delete)
            if (_agents.containsKey(agentName)) {
                // This block handles Agents that have previously been registered
                Agent agent = _agents.get(agentName);
                long originalEpoch = agent.getEpoch();
                // If we already know about an Agent we simply update the Agent's state using initialise()
                agent.initialise(AMQPMessage.getMap(message));
                // If the Epoch has changed it means the Agent has been restarted so we send a notification
                if (agent.getEpoch() != originalEpoch) {
                    // Clear cache to force a lookup
                    agent.clearSchemaCache();
                    List<SchemaClassId> classes = getClasses(agent);
                    // Discover the schema for this Agent and cache it
                    getSchema(classes, agent);
                    _log.info("Agent {} has been restarted", agentName);
                    if (_discoverAgents && (_agentQuery == null || _agentQuery.evaluate(agent))) {
                        _eventListener.onEvent(new AgentRestartedWorkItem(agent));
                    }
                } else {
                    // Otherwise just send a heartbeat notification
                    _log.info("Agent {} heartbeat", agent.getName());
                    if (_discoverAgents && (_agentQuery == null || _agentQuery.evaluate(agent))) {
                        _eventListener.onEvent(new AgentHeartbeatWorkItem(agent));
                    }
                }
            } else {
                // This block handles Agents that haven't already been registered
                Agent agent = new Agent(AMQPMessage.getMap(message), this);
                List<SchemaClassId> classes = getClasses(agent);
                // Discover the schema for this Agent and cache it
                getSchema(classes, agent);
                _agents.put(agentName, agent);
                _log.info("Adding Agent {}", agentName);
                // the Agent more "user friendly" than using the full Agent name.
                if (agent.getVendor().equals("apache.org") && agent.getProduct().equals("qpidd")) {
                    _log.info("Recording {} as _brokerAgentName", agentName);
                    _brokerAgentName = agentName;
                }
                // wait for the broker Agent to become available.
                if (_brokerAgentName != null) {
                    synchronized (this) {
                        _agentAvailable = true;
                        notifyAll();
                    }
                }
                if (_discoverAgents && (_agentQuery == null || _agentQuery.evaluate(agent))) {
                    _eventListener.onEvent(new AgentAddedWorkItem(agent));
                }
            }
            // The broker Agent sends periodic heartbeats and that Agent should *always* be available given
            // a running broker, so we should get here every "--mgmt-pub-interval" seconds or so, so it's
            // a good place to periodically check for the expiry of any other Agents.
            handleAgentExpiry();
            return;
        }
        if (!_agents.containsKey(agentName)) {
            _log.info("Ignoring Event from unregistered Agent {}", agentName);
            return;
        }
        Agent agent = _agents.get(agentName);
        if (!agent.eventsEnabled()) {
            _log.info("{} has disabled Event reception, ignoring Event", agentName);
            return;
        }
        // If we get to here the Agent from whence the Event came should be registered and should
        // have Event reception enabled, so we should be able to send events to the EventListener
        Handle handle = new Handle(message.getJMSCorrelationID());
        if (opcode.equals("_method_response") || opcode.equals("_exception")) {
            if (AMQPMessage.isAMQPMap(message)) {
                _eventListener.onEvent(new MethodResponseWorkItem(handle, new MethodResult(AMQPMessage.getMap(message))));
            } else {
                _log.info("onMessage() Received Method Response message in incorrect format");
            }
        }
        // refresh() call on QmfConsoleData so the number of results in the returned list *should* be one.
        if (opcode.equals("_query_response") && content.equals("_data")) {
            if (AMQPMessage.isAMQPList(message)) {
                List<Map> list = AMQPMessage.getList(message);
                for (Map m : list) {
                    _eventListener.onEvent(new ObjectUpdateWorkItem(handle, new QmfConsoleData(m, agent)));
                }
            } else {
                _log.info("onMessage() Received Query Response message in incorrect format");
            }
        }
        // This block handles responses to createSubscription and refreshSubscription
        if (opcode.equals("_subscribe_response")) {
            if (AMQPMessage.isAMQPMap(message)) {
                String correlationId = message.getJMSCorrelationID();
                SubscribeParams params = new SubscribeParams(correlationId, AMQPMessage.getMap(message));
                String subscriptionId = params.getSubscriptionId();
                if (subscriptionId != null && correlationId != null) {
                    SubscriptionManager subscription = _subscriptionById.get(subscriptionId);
                    if (subscription == null) {
                        // This is a createSubscription response so the correlationId should be the consoleHandle
                        subscription = _subscriptionByHandle.get(correlationId);
                        if (subscription != null) {
                            _subscriptionById.put(subscriptionId, subscription);
                            subscription.setSubscriptionId(subscriptionId);
                            subscription.setDuration(params.getLifetime());
                            String replyHandle = subscription.getReplyHandle();
                            if (replyHandle == null) {
                                subscription.signal();
                            } else {
                                _eventListener.onEvent(new SubscribeResponseWorkItem(new Handle(replyHandle), params));
                            }
                        }
                    } else {
                        // This is a refreshSubscription response
                        params.setConsoleHandle(subscription.getConsoleHandle());
                        subscription.setDuration(params.getLifetime());
                        subscription.refresh();
                        _eventListener.onEvent(new SubscribeResponseWorkItem(handle, params));
                    }
                }
            } else {
                _log.info("onMessage() Received Subscribe Response message in incorrect format");
            }
        }
        // Subscription Indication - in other words the asynchronous results of a Subscription
        if (opcode.equals("_data_indication") && content.equals("_data")) {
            if (AMQPMessage.isAMQPList(message)) {
                String consoleHandle = handle.getCorrelationId();
                if (consoleHandle != null && _subscriptionByHandle.containsKey(consoleHandle)) {
                    // If we have a valid consoleHandle the data has come from a "real" Subscription.
                    List<Map> list = AMQPMessage.getList(message);
                    List<QmfConsoleData> resultList = new ArrayList<QmfConsoleData>(list.size());
                    for (Map m : list) {
                        resultList.add(new QmfConsoleData(m, agent));
                    }
                    _eventListener.onEvent(new SubscriptionIndicationWorkItem(new SubscribeIndication(consoleHandle, resultList)));
                } else if (_subscriptionEmulationEnabled && agentName.equals(_brokerAgentName)) {
                    // If the data has come from is the broker Agent we emulate a Subscription on the Console
                    for (SubscriptionManager subscription : _subscriptionByHandle.values()) {
                        QmfQuery query = subscription.getQuery();
                        if (subscription.getAgent().getName().equals(_brokerAgentName) && query.getTarget() == QmfQueryTarget.OBJECT) {
                            // Only evaluate broker Agent subscriptions with QueryTarget == OBJECT on the Console.
                            long objectEpoch = 0;
                            consoleHandle = subscription.getConsoleHandle();
                            List<Map> list = AMQPMessage.getList(message);
                            List<QmfConsoleData> resultList = new ArrayList<QmfConsoleData>(list.size());
                            for (Map m : list) {
                                // Evaluate the QmfConsoleData object against the query
                                QmfConsoleData object = new QmfConsoleData(m, agent);
                                if (query.evaluate(object)) {
                                    long epoch = object.getObjectId().getAgentEpoch();
                                    objectEpoch = (epoch > objectEpoch && !object.isDeleted()) ? epoch : objectEpoch;
                                    resultList.add(object);
                                }
                            }
                            if (resultList.size() > 0) {
                                // data from the restarted Agent (in case they need to reset any state).
                                if (objectEpoch > agent.getEpoch()) {
                                    agent.setEpoch(objectEpoch);
                                    // Clear cache to force a lookup
                                    agent.clearSchemaCache();
                                    List<SchemaClassId> classes = getClasses(agent);
                                    // Discover the schema for this Agent and cache it
                                    getSchema(classes, agent);
                                    _log.info("Agent {} has been restarted", agentName);
                                    if (_discoverAgents && (_agentQuery == null || _agentQuery.evaluate(agent))) {
                                        _eventListener.onEvent(new AgentRestartedWorkItem(agent));
                                    }
                                }
                                _eventListener.onEvent(new SubscriptionIndicationWorkItem(new SubscribeIndication(consoleHandle, resultList)));
                            }
                        }
                    }
                }
            } else {
                _log.info("onMessage() Received Subscribe Indication message in incorrect format");
            }
        }
        // The results of an Event delivered from an Agent
        if (opcode.equals("_data_indication") && content.equals("_event")) {
            // There are differences in the type of message sent by Qpid 0.8 and 0.10 onwards.
            if (AMQPMessage.isAMQPMap(message)) {
                // 0.8 broker passes Events as amqp/map encoded as MapMessages (we convert into java.util.Map)
                _eventListener.onEvent(new EventReceivedWorkItem(agent, new QmfEvent(AMQPMessage.getMap(message))));
            } else if (AMQPMessage.isAMQPList(message)) {
                // 0.10 and above broker passes Events as amqp/list encoded as BytesMessage (needs decoding)
                // 0.20 encodes amqp/list in a MapMessage!!?? AMQPMessage hopefully abstracts this detail.
                List<Map> list = AMQPMessage.getList(message);
                for (Map m : list) {
                    _eventListener.onEvent(new EventReceivedWorkItem(agent, new QmfEvent(m)));
                }
            } else {
                _log.info("onMessage() Received Event message in incorrect format");
            }
        }
    } catch (JMSException jmse) {
        _log.info("JMSException {} caught in onMessage()", jmse.getMessage());
    }
}

Example 8 with Handle

use of org.apache.qpid.qmf2.common.Handle in project qpid by apache.

the class Console method createSubscription.

/**
 * Creates a subscription to the agent using the given Query.
 * <p>
 * The consoleHandle is an application-provided handle that will accompany each subscription update sent from
 * the Agent. Subscription updates will appear as SUBSCRIPTION_INDICATION WorkItems on the Console's work queue.
 * <p>
 * The publishInterval is the requested time interval in seconds on which the Agent should publish updates.
 * <p>
 * The lifetime parameter is the requested time interval in seconds for which this subscription should remain in
 * effect. Both the requested lifetime and publishInterval may be overridden by the Agent, as indicated in the
 * subscription response.
 * <p>
 * This method may be called asynchronously by providing a replyHandle argument. When called
 * asynchronously, the result of this method call is returned in a SUBSCRIBE_RESPONSE WorkItem with a
 * handle matching the value of replyHandle.
 * <p>
 * Timeout can be used to override the console's default reply timeout.
 * <p>
 * When called synchronously, this method returns a SubscribeParams object containing the result of the
 * subscription request.
 *
 * @param agent the Agent on which to create the subscription.
 * @param query the Query to perform on the Agent
 * @param consoleHandle an application-provided handle that will accompany each subscription update sent
 *        from the Agent.
 * @param options a String representation of a Map containing the options in the form
 *        <pre>"{lifetime:&lt;value&gt;, publishInterval:&lt;value&gt;, replyHandle:&lt;value&gt;, timeout:&lt;value&gt;}"</pre>
 *        they are optional and may appear in any order.
 * <pre>
 *        <b>lifetime</b> the requested time interval in seconds for which this subscription should remain in effect.
 *        <b>publishInterval</b> the requested time interval in seconds on which the Agent should publish updates
 *        <b>replyHandle</b> the correlation handle used to tie asynchronous method requests with responses.
 *        <b>timeout</b> the time to wait for a reply from the Agent.
 * </pre>
 */
public synchronized SubscribeParams createSubscription(final Agent agent, final QmfQuery query, final String consoleHandle, final String options) throws QmfException {
    if (consoleHandle == null) {
        throw new QmfException("Called createSubscription() with null consoleHandle");
    }
    if (_subscriptionByHandle.get(consoleHandle) != null) {
        throw new QmfException("Called createSubscription() with a consoleHandle that is already in use");
    }
    if (agent == null) {
        throw new QmfException("Called createSubscription() with null agent");
    }
    if (!agent.isActive()) {
        throw new QmfException("Called createSubscription() with inactive agent");
    }
    String agentName = agent.getName();
    // Initialise optional values to defaults;
    long lifetime = _subscriptionDuration;
    long publishInterval = 10000;
    long timeout = _replyTimeout;
    String replyHandle = null;
    if (options != null) {
        // We wrap the Map in a QmfData object to avoid potential class cast issues with the parsed options
        QmfData optMap = new QmfData(new AddressParser(options).map());
        if (optMap.hasValue("lifetime")) {
            lifetime = optMap.getLongValue("lifetime");
        }
        if (optMap.hasValue("publishInterval")) {
            // Multiply publishInterval by 1000 because the QMF2 protocol spec says interval is
            // "The request time (in milliseconds) between periodic updates of data in this subscription"
            publishInterval = 1000 * optMap.getLongValue("publishInterval");
        }
        if (optMap.hasValue("timeout")) {
            timeout = optMap.getLongValue("timeout");
        }
        if (optMap.hasValue("replyHandle")) {
            replyHandle = optMap.getStringValue("replyHandle");
        }
    }
    try {
        MapMessage request = _syncSession.createMapMessage();
        // Deliberately forcing all replies to the _asyncReplyAddress
        request.setJMSReplyTo(_asyncReplyAddress);
        // Deliberately using consoleHandle not replyHandle here
        request.setJMSCorrelationID(consoleHandle);
        request.setStringProperty("x-amqp-0-10.app-id", "qmf2");
        request.setStringProperty("method", "request");
        request.setStringProperty("qmf.opcode", "_subscribe_request");
        request.setStringProperty("qpid.subject", agentName);
        request.setObject("_query", query.mapEncode());
        request.setObject("_interval", publishInterval);
        request.setObject("_duration", lifetime);
        SubscriptionManager subscription = new SubscriptionManager(agent, query, consoleHandle, replyHandle, publishInterval, lifetime);
        _subscriptionByHandle.put(consoleHandle, subscription);
        _timer.schedule(subscription, 0, publishInterval);
        if (_subscriptionEmulationEnabled && agentName.equals(_brokerAgentName)) {
            // If the Agent is the broker Agent we emulate the Subscription on the Console
            String subscriptionId = UUID.randomUUID().toString();
            _subscriptionById.put(subscriptionId, subscription);
            subscription.setSubscriptionId(subscriptionId);
            final SubscribeParams params = new SubscribeParams(consoleHandle, subscription.mapEncode());
            if (replyHandle == null) {
                return params;
            } else {
                final String handle = replyHandle;
                Thread thread = new Thread() {

                    public void run() {
                        _eventListener.onEvent(new SubscribeResponseWorkItem(new Handle(handle), params));
                    }
                };
                thread.start();
            }
            return null;
        }
        _requester.send(request);
        if (replyHandle == null) {
            // If this is an synchronous request get the response
            subscription.await(timeout * 1000);
            if (subscription.getSubscriptionId() == null) {
                _log.info("No response received in createSubscription()");
                throw new QmfException("No response received for Console.createSubscription()");
            }
            return new SubscribeParams(consoleHandle, subscription.mapEncode());
        }
        // If this is an asynchronous request return without waiting for a response
        return null;
    } catch (JMSException jmse) {
        _log.info("JMSException {} caught in createSubscription()", jmse.getMessage());
        throw new QmfException(jmse.getMessage());
    }
}

Example 9 with Handle

use of org.apache.qpid.qmf2.common.Handle in project qpid by apache.

the class Agent method onMessage.

// MessageListener
// ********************************************************************************************************
/**
 * MessageListener for QMF2 Console requests.
 *
 * @param message the JMS Message passed to the listener.
 */
public final void onMessage(final Message message) {
    try {
        String agentName = QmfData.getString(message.getObjectProperty("qmf.agent"));
        String content = QmfData.getString(message.getObjectProperty("qmf.content"));
        String opcode = QmfData.getString(message.getObjectProperty("qmf.opcode"));
        // String routingKey = ((javax.jms.Topic)message.getJMSDestination()).getTopicName();
        // String contentType = ((org.apache.qpid.client.message.AbstractJMSMessage)message).getContentType();
        // System.out.println();
        // System.out.println("agentName = " + agentName);
        // System.out.println("content = " + content);
        // System.out.println("opcode = " + opcode);
        // System.out.println("routingKey = " + routingKey);
        // System.out.println("contentType = " + contentType);
        Handle handle = new Handle(message.getJMSCorrelationID(), message.getJMSReplyTo());
        if (opcode.equals("_agent_locate_request")) {
            handleLocateRequest(handle);
        } else if (opcode.equals("_method_request")) {
            if (AMQPMessage.isAMQPMap(message)) {
                _eventListener.onEvent(new MethodCallWorkItem(handle, new MethodCallParams(AMQPMessage.getMap(message))));
            } else {
                _log.info("onMessage() Received Method Request message in incorrect format");
            }
        } else if (opcode.equals("_query_request")) {
            if (AMQPMessage.isAMQPMap(message)) {
                try {
                    QmfQuery query = new QmfQuery(AMQPMessage.getMap(message));
                    handleQueryRequest(handle, query);
                } catch (QmfException qmfe) {
                    raiseException(handle, "Query Request failed, invalid Query: " + qmfe.getMessage());
                }
            } else {
                _log.info("onMessage() Received Query Request message in incorrect format");
            }
        } else if (opcode.equals("_subscribe_request")) {
            if (AMQPMessage.isAMQPMap(message)) {
                try {
                    SubscriptionParams subscriptionParams = new SubscriptionParams(handle, AMQPMessage.getMap(message));
                    if (this instanceof AgentExternal) {
                        _eventListener.onEvent(new SubscribeRequestWorkItem(handle, subscriptionParams));
                    } else {
                        Subscription subscription = new Subscription(this, subscriptionParams);
                        String subscriptionId = subscription.getSubscriptionId();
                        _subscriptions.put(subscriptionId, subscription);
                        _timer.schedule(subscription, 0, subscriptionParams.getPublishInterval());
                        subscriptionResponse(handle, subscription.getConsoleHandle(), subscriptionId, subscription.getDuration(), subscription.getInterval(), null);
                    }
                } catch (QmfException qmfe) {
                    raiseException(handle, "Subscribe Request failed, invalid Query: " + qmfe.getMessage());
                }
            } else {
                _log.info("onMessage() Received Subscribe Request message in incorrect format");
            }
        } else if (opcode.equals("_subscribe_refresh_indication")) {
            if (AMQPMessage.isAMQPMap(message)) {
                ResubscribeParams resubscribeParams = new ResubscribeParams(AMQPMessage.getMap(message));
                if (this instanceof AgentExternal) {
                    _eventListener.onEvent(new ResubscribeRequestWorkItem(handle, resubscribeParams));
                } else {
                    String subscriptionId = resubscribeParams.getSubscriptionId();
                    Subscription subscription = _subscriptions.get(subscriptionId);
                    if (subscription != null) {
                        subscription.refresh(resubscribeParams);
                        subscriptionResponse(handle, subscription.getConsoleHandle(), subscription.getSubscriptionId(), subscription.getDuration(), subscription.getInterval(), null);
                    }
                }
            } else {
                _log.info("onMessage() Received Resubscribe Request message in incorrect format");
            }
        } else if (opcode.equals("_subscribe_cancel_indication")) {
            if (AMQPMessage.isAMQPMap(message)) {
                QmfData qmfSubscribe = new QmfData(AMQPMessage.getMap(message));
                String subscriptionId = qmfSubscribe.getStringValue("_subscription_id");
                if (this instanceof AgentExternal) {
                    _eventListener.onEvent(new UnsubscribeRequestWorkItem(subscriptionId));
                } else {
                    Subscription subscription = _subscriptions.get(subscriptionId);
                    if (subscription != null) {
                        subscription.cancel();
                    }
                }
            } else {
                _log.info("onMessage() Received Subscribe Cancel Request message in incorrect format");
            }
        }
    } catch (JMSException jmse) {
        _log.info("JMSException {} caught in onMessage()", jmse.getMessage());
    }
}

Example 10 with Handle

use of org.apache.qpid.qmf2.common.Handle in project qpid by apache.

the class Agent method queryResponse.

/**
 * Send the query response back to the Console.
 * @param handle the reply handle that contains the replyTo Address.
 * @param results the list of mapEncoded query results.
 * @param qmfContentType the value to be passed to the qmf.content Header.
 */
protected final void queryResponse(final Handle handle, List<Map> results, final String qmfContentType) {
    try {
        Message response = AMQPMessage.createListMessage(_syncSession);
        response.setJMSCorrelationID(handle.getCorrelationId());
        response.setStringProperty("x-amqp-0-10.app-id", "qmf2");
        response.setStringProperty("method", "response");
        response.setStringProperty("qmf.opcode", "_query_response");
        response.setStringProperty("qmf.agent", _name);
        response.setStringProperty("qmf.content", qmfContentType);
        response.setStringProperty("qpid.subject", handle.getRoutingKey());
        AMQPMessage.setList(response, results);
        sendResponse(handle, response);
    } catch (JMSException jmse) {
        _log.info("JMSException {} caught in queryResponse()", jmse.getMessage());
    }
}