| #ifndef _QPID_CONSOLE_SESSION_MANAGER_H |
| #define _QPID_CONSOLE_SESSION_MANAGER_H |
| |
| /* |
| * |
| * 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. |
| * |
| */ |
| |
| #include "qpid/console/ConsoleImportExport.h" |
| #include "qpid/console/Broker.h" |
| #include "qpid/console/Package.h" |
| #include "qpid/console/SequenceManager.h" |
| #include "qpid/console/ClassKey.h" |
| #include "qpid/console/Schema.h" |
| #include "qpid/console/Agent.h" |
| #include "qpid/console/Object.h" |
| #include "qpid/console/ObjectId.h" |
| #include "qpid/console/Value.h" |
| #include "qpid/sys/Mutex.h" |
| #include "qpid/sys/Condition.h" |
| #include "qpid/client/ConnectionSettings.h" |
| #include <string> |
| #include <vector> |
| |
| namespace qpid { |
| namespace console { |
| |
| class ConsoleListener; |
| |
| /** |
| * |
| * \ingroup qmfconsoleapi |
| */ |
| class QPID_CONSOLE_CLASS_EXTERN SessionManager |
| { |
| public: |
| typedef std::vector<std::string> NameVector; |
| typedef std::vector<ClassKey> KeyVector; |
| QPID_CONSOLE_EXTERN ~SessionManager(); |
| |
| struct QPID_CONSOLE_CLASS_EXTERN Settings { |
| bool rcvObjects; |
| bool rcvEvents; |
| bool rcvHeartbeats; |
| bool userBindings; |
| uint32_t methodTimeout; |
| uint32_t getTimeout; |
| |
| Settings() : rcvObjects(true), rcvEvents(true), rcvHeartbeats(true), |
| userBindings(false), methodTimeout(20), getTimeout(20) |
| {} |
| }; |
| |
| /** Create a new SessionManager |
| * |
| * Provide your own subclass of ConsoleListener to receive updates and indications |
| * asynchronously or leave it as its default and use only synchronous methods. |
| * |
| *@param listener Listener object to receive asynchronous indications. |
| *@param settings.rcvObjects Listener wishes to receive managed object data. |
| *@param settings.rcvEvents Listener wishes to receive events. |
| *@param settings.rcvHeartbeats Listener wishes to receive agent heartbeats. |
| *@param settings.userBindings If rcvObjects is true, userBindings allows the |
| * console client to control which object classes are received. See the bindPackage |
| * and bindClass methods. If userBindings is false, the listener will receive |
| * updates for all object classes. |
| */ |
| QPID_CONSOLE_EXTERN SessionManager(ConsoleListener* listener = 0, |
| Settings settings = Settings()); |
| |
| /** Connect a broker to the console session |
| * |
| *@param settings Connection settings for client access |
| *@return broker object if operation is successful |
| * an exception shall be thrown. |
| */ |
| QPID_CONSOLE_EXTERN Broker* addBroker(client::ConnectionSettings& settings); |
| |
| /** Disconnect a broker from the console session |
| * |
| *@param broker The broker object returned from an earlier call to addBroker. |
| */ |
| QPID_CONSOLE_EXTERN void delBroker(Broker* broker); |
| |
| /** Get a list of known management packages |
| * |
| *@param packages Vector of package names returned by the session manager. |
| */ |
| QPID_CONSOLE_EXTERN void getPackages(NameVector& packages); |
| |
| /** Get a list of class keys associated with a package |
| * |
| *@param classKeys List of class keys returned by the session manager. |
| *@param packageName Name of package being queried. |
| */ |
| QPID_CONSOLE_EXTERN void getClasses(KeyVector& classKeys, |
| const std::string& packageName); |
| |
| /** Get the schema of a class given its class key |
| * |
| *@param classKey Class key of the desired schema. |
| */ |
| QPID_CONSOLE_EXTERN SchemaClass& getSchema(const ClassKey& classKey); |
| |
| /** Request that updates be received for all classes within a package |
| * |
| * Note that this method is only meaningful if a ConsoleListener was provided at session |
| * creation and if the 'userBindings' flag was set to true. |
| * |
| *@param packageName Name of the package to which to bind. |
| */ |
| QPID_CONSOLE_EXTERN void bindPackage(const std::string& packageName); |
| |
| /** Request update to be received for a particular class |
| * |
| * Note that this method is only meaningful if a ConsoleListener was provided at session |
| * creation and if the 'userBindings' flag was set to true. |
| * |
| *@param classKey Class key of class to which to bind. |
| */ |
| QPID_CONSOLE_EXTERN void bindClass(const ClassKey& classKey); |
| QPID_CONSOLE_EXTERN void bindClass(const std::string& packageName, |
| const std::string& className); |
| |
| /** Request events from a particular package. |
| * |
| * Note that this method is only meaningful if a ConsoleListener was provided at session |
| * creation and if the 'userBindings' flag was set to true. |
| * |
| * @param classKey Class key of event of interest |
| * @param packageName Name of package of event of interest. |
| * @param eventName Name of event of interest. Default=All events defined by package. |
| */ |
| QPID_CONSOLE_EXTERN void bindEvent(const ClassKey& classKey); |
| QPID_CONSOLE_EXTERN void bindEvent(const std::string& packageName, |
| const std::string& eventName=""); |
| |
| |
| /** Get a list of qmf agents known to the session manager. |
| * |
| *@param agents Vector of Agent objects returned by the session manager. |
| *@param broker Return agents registered with this broker only. If NULL, return agents |
| * from all connected brokers. |
| */ |
| QPID_CONSOLE_EXTERN void getAgents(Agent::Vector& agents, |
| Broker* broker = 0); |
| |
| /** Get objects from agents. There are four variants of this method with different ways of |
| * specifying from which class objects are being queried. |
| * |
| *@param objects List of objects received. |
| *@param classKey ClassKey object identifying class to be queried. |
| *@param className Class name identifying class to be queried. |
| *@param objectId Object Id of the single object to be queried. |
| *@param broker Restrict the query to this broker, or all brokers if NULL. |
| *@param agent Restrict the query to this agent, or all agents if NULL. |
| */ |
| QPID_CONSOLE_EXTERN void getObjects(Object::Vector& objects, |
| const std::string& className, |
| Broker* broker = 0, |
| Agent* agent = 0); |
| //void getObjects(Object::Vector& objects, const ClassKey& classKey, |
| // Broker* broker = 0, Agent* agent = 0); |
| //void getObjects(Object::Vector& objects, const ObjectId& objectId, |
| // Broker* broker = 0, Agent* agent = 0); |
| |
| private: |
| friend class Broker; |
| friend class Broker::ConnectionThread; |
| friend class Object; |
| sys::Mutex lock; |
| sys::Mutex brokerListLock; |
| ConsoleListener* listener; |
| std::vector<Broker*> brokers; |
| std::map<std::string, Package*> packages; |
| SequenceManager sequenceManager; |
| sys::Condition cv; |
| SequenceManager::set syncSequenceList; |
| Object::Vector getResult; |
| std::string error; |
| Settings settings; |
| NameVector bindingKeyList; |
| |
| void bindingKeys(); |
| void allBrokersStable(); |
| void startProtocol(Broker* broker); |
| void handleBrokerResp(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handlePackageInd(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleCommandComplete(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleClassInd(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleMethodResp(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleHeartbeatInd(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleEventInd(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleSchemaResp(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence); |
| void handleContentInd(Broker* broker, framing::Buffer& inBuffer, uint32_t sequence, bool prop, bool stat); |
| void handleBrokerConnect(Broker* broker); |
| void handleBrokerDisconnect(Broker* broker); |
| |
| }; |
| |
| }} // namespace qpid::console |
| |
| #endif /*!_QPID_CONSOLE_SESSION_MANAGER_H*/ |