#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 #include namespace qpid { namespace console { class ConsoleListener; /** * * \ingroup qmfconsoleapi */ class SessionManager { public: typedef std::vector NameVector; typedef std::vector KeyVector; QPID_CONSOLE_EXTERN ~SessionManager(); struct 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 brokers; std::map 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*/