qpid/console/SessionManager.h

Go to the documentation of this file.

#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;

class SessionManager
{
  public:
    typedef std::vector<std::string> NameVector;
    typedef std::vector<ClassKey> 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)
        {}
    };

    QPID_CONSOLE_EXTERN SessionManager(ConsoleListener* listener = 0,
                                       Settings settings = Settings());

    QPID_CONSOLE_EXTERN Broker* addBroker(client::ConnectionSettings& settings);

    QPID_CONSOLE_EXTERN void delBroker(Broker* broker);

    QPID_CONSOLE_EXTERN void getPackages(NameVector& packages);

    QPID_CONSOLE_EXTERN void getClasses(KeyVector& classKeys,
                                        const std::string& packageName);

    QPID_CONSOLE_EXTERN SchemaClass& getSchema(const ClassKey& classKey);

    QPID_CONSOLE_EXTERN void bindPackage(const std::string& packageName);

    QPID_CONSOLE_EXTERN void bindClass(const ClassKey& classKey);
    QPID_CONSOLE_EXTERN void bindClass(const std::string& packageName,
                                       const std::string& className);

    QPID_CONSOLE_EXTERN void bindEvent(const ClassKey& classKey);
    QPID_CONSOLE_EXTERN void bindEvent(const std::string& packageName,
                                       const std::string& eventName="");


    QPID_CONSOLE_EXTERN void getAgents(Agent::Vector& agents,
                                       Broker* broker = 0);

    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