networkmanager_i.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Huang Yong Feng (hyf)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.39 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _NETWORKMANAGER_I_H_
#define _NETWORKMANAGER_I_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>
#include <map>

// + OSB library headers
#include "mutex.h"
#include "dbsession.h"

#include "network.h"
#include "resourcelists.h"

// + local headers
#include "utf8string.h"

#include "inventorypoolC.h"
#include "tariffobjectC.h"
#include "networkmanagerS.h"
#include "servantlocators.h"

// class declaration
namespace OSB_LIB {
    class ResourceLists;
    class InventoryPool;
}

namespace corba {
  namespace imgmt {
      class Pools;
      class Pool;
      class PoolId;
  }
}

// *********************************************************************
// namespace extensions
namespace OSB_CORBA {
    using namespace corba::nwmgr::nw;
    using namespace corba::nwmgr::nwe;
    using namespace corba::res;
    using namespace corba::nwmgr::trk;
    using namespace corba::nwmgr;

    using corba::common::OsbCorbaException;
    using corba::common::ServerInfo;
    using corba::tcat::cp::ConnectionPt;
    using corba::tcat::cp::ConnectionPtId;
    using corba::tcat::cp::ConnectionPtSeq;

    // *****************************************************************
    // class NetworkManager_i
    class NetworkManager_i :
        public virtual POA_corba::nwmgr::NetworkManager
    {
    public:
        static const std::string IFC;

        NetworkManager_i(
            const ServerInfo&              info,
            PortableServer::POA_ptr        rootPoa,
            PortableServer::POAManager_ptr poaManager
        ) throw (OsbCorbaException);

        virtual ~NetworkManager_i();

    private:
        NetworkManager_i(const NetworkManager_i&);
        NetworkManager_i& operator=(const NetworkManager_i&);

    public:                             // Network
        virtual ServerInfo* getServerInfo()
            throw (CORBA::SystemException);

        void ping() throw();

        virtual NetworkElementMgr_ptr getNetworkElementMgr()
            throw (CORBA::SystemException);

        virtual TrunkGroupMgr_ptr getTrunkGroupMgr()
            throw (CORBA::SystemException);

        virtual Network_ptr getNetwork(
            const NetworkId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual NetworkSeq* getNetworks()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual Network_ptr creNetwork(
            const Utf8String& name,
            const Utf8String& desc,
            const TimeZoneId& tzId,
            CORBA::Boolean    noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual void delNetwork(
            const NetworkId& id,
            CORBA::Boolean   noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

        corba::imgmt::Pools* inventoryPools(
            CORBA::Boolean force
        ) throw (CORBA::SystemException, OsbCorbaException);

        corba::imgmt::PoolId savePool (
          corba::imgmt::Pool& pool,
          CORBA::Boolean      noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

        corba::imgmt::DvcRsrcMgr* mkDvcRsrcMgr()
          throw (CORBA::SystemException);

        OSB_LIB::ResourceLists& resourceLists();

    public:                             // TrunkResource
        typedef OSB_LIB::ResourceLists::TrList TrList;

        TrList& getTrList();

        virtual TrunkResource_ptr getTr(
            const ResourceId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual TrunkResourceSeq* getTrs()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual TrunkResourceSeq* getTrsOfNetwork(
            const NetworkId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual TrunkResourceWriter_ptr creNewTr(
            const Utf8String& rn,
            const NetworkId&  nwId
        ) throw (CORBA::SystemException);

        virtual void delTr(
            const ResourceId&    id,
                  CORBA::Boolean noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    public:                             // AccessNumber
        typedef OSB_LIB::ResourceLists::AnList AnList;

        AnList& getAnList();

        virtual AccessNumber_ptr getAn(
            const ResourceId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual AccessNumberSeq* getAns()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual AccessNumberSeq* getAnsOfNetwork(
            const NetworkId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual AccessNumberWriter_ptr creNewAn(
            const Utf8String& rn,
            const NetworkId&  nwId
        ) throw (CORBA::SystemException);

        virtual void delAn(
            const ResourceId&    id,
                  CORBA::Boolean noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    public:                             // E.164 resources
        typedef OSB_LIB::ResourceLists::E164List E164List;

        E164List& getE164List();

        E164Resource_ptr getE164(
            const ResourceId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        E164ResourceSeq* searchE164s(
                  ResourceStatus status,
            const Utf8String&    pattern,
                  int            maxNum
        ) throw (CORBA::SystemException, OsbCorbaException);

        E164ResourceSeq* createE164s(
            const NetworkElementId& neId,
            const Utf8String&       ccNdc,
            const Utf8String&       first,
                  int               qnty
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual void delE164(
            const ResourceId&    id,
                  CORBA::Boolean noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    private:
        E164ResourceSeq* creE164Servants(
            const E164List&    src,
            const std::string& module
        );

    public:                             // Connection point
        virtual ConnectionPt* getConnectionPt(
            const ConnectionPtId& cpId
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual ConnectionPtSeq* getConnectionPts()
            throw (CORBA::SystemException);

    public:                             // TimeZone
        virtual TimeZone* getTimeZone(const TimeZoneId& id)
            throw (CORBA::SystemException, OsbCorbaException);

        virtual TimeZoneSeq* getTimeZones()
            throw (CORBA::SystemException, OsbCorbaException);

    public:                             // Ip4Address
        typedef OSB_LIB::ResourceLists::Ip4List Ip4List;

        Ip4List& getIp4List();

        virtual Ip4Address_ptr getIp4(
            const ResourceId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual Ip4AddressSeq* getIp4s()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual Ip4AddressSeq* getIp4sOfNetwork(
            const NetworkId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual Ip4AddressWriter_ptr creNewIp4(
            const Utf8String& rn,
            const NetworkId&  nwId
        ) throw (CORBA::SystemException);

        virtual void delIp4(
            const ResourceId&    id,
                  CORBA::Boolean noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    public:                             // IpGroup
        typedef OSB_LIB::ResourceLists::IpGroupList IpgList;

        IpgList& getIpgList();

        virtual IpGroup_ptr getIpg(
            const ResourceId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual IpGroupSeq* getIpgs()
            throw (CORBA::SystemException, OsbCorbaException);

        virtual IpGroupSeq* getIpgsOfNetwork(
            const NetworkId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        virtual IpGroupWriter_ptr creNewIpg(
            const Utf8String& rn,
            const NetworkId&  nwId
        ) throw (CORBA::SystemException);

        virtual void delIpg(
            const ResourceId&    id,
                  CORBA::Boolean noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    public:
        PortableServer::POA_ptr networkPoa();

        PortableServer::POA_ptr nwElementPoa();

        PortableServer::POA_ptr trkGroupPoa();

        PortableServer::POA_ptr numAnalyzerPoa();

        PortableServer::POA_ptr writerPoa();

        PortableServer::POA_ptr nweMgrPoa();

        PortableServer::POA_ptr trkMgrPoa();

        PortableServer::POA_ptr rsrcPoa();
        PortableServer::POA_ptr dvcPoa();

        Locators& networkLoc();
        Locators& nwElementLoc();
        Locators& trkGroupLoc();
        Locators& numAnalyzerLoc();

        Locators& writerLoc();

        Locators& drMgrLoc();
        Locators& rsrcLoc();
        Locators& dvcLoc();

    private:
        typedef std::list<OSB_LIB::InventoryPool> InvPools;
        OSB_LIB::ResourceLists* resourceLists_;
        InvPools* invPools_;

    private:
        ServerInfo info_;

        const std::string nweMgrOidStr_;

        const std::string trkMgrOidStr_;

        // *************************************************************
        // POA definitions
        PortableServer::POA_var networkPoa_;
        PortableServer::POA_var nwElementPoa_;
        PortableServer::POA_var trkGroupPoa_;
        PortableServer::POA_var numAnalyzerPoa_;

        PortableServer::POA_var writerPoa_;

        PortableServer::POA_var nweMgrPoa_;
        PortableServer::POA_var trkMgrPoa_;

        PortableServer::POA_var rsrcPoa_;

        PortableServer::POA_var drMgrPoa_;

        PortableServer::POA_var dvcPoa_;

        // *************************************************************
        // Servant locator definitions
        Locators networkLoc_;
        Locators nwElementLoc_;
        Locators trkGroupLoc_;
        Locators numAnalyzerLoc_;

        Locators writerLoc_;

        Locators drMgrLoc_;
        Locators rsrcLoc_;
        Locators dvcLoc_;

    private:
        void createPoas(
            PortableServer::POA_ptr        rootPoa,
            PortableServer::POAManager_ptr poaManager
        );

        void createMgrPoas(
            PortableServer::POA_ptr        rootPoa,
            PortableServer::POAManager_ptr poaManager
        );
    };                                  // class NetworkManager_i

    // *****************************************************************
    // class NetworkElementMgr
    class NetworkElementMgr_i :
        public virtual POA_corba::nwmgr::NetworkElementMgr
    {
    public:
        static const std::string IFC;
        NetworkElementMgr_i(NetworkManager_i& nmgri);
        virtual ~NetworkElementMgr_i();

        NetworkElementWriter_ptr creNewElement(
            const NetworkId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        //NetworkElement_ptr addElement(
        //    NetworkElementWriter& nweWriter
        //) throw (OsbCorbaException);

        void delElement(
           const NetworkElementId& id,
                 CORBA::Boolean    noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    private:
        NetworkManager_i& nmgri_;
    };                                  // class NetworkElementMgr_i

    // *****************************************************************
    // class TrunkGroupMgr
    class TrunkGroupMgr_i :
        public virtual POA_corba::nwmgr::TrunkGroupMgr
    {
    public:
        static const std::string IFC;
        TrunkGroupMgr_i(NetworkManager_i& nmgri);

    public:
        TrunkGroup_ptr getTrkGroup(
            const TrunkGroupId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        TrunkGroupWriter_ptr creNewTrkGroup(
            const NetworkElementId& id
        ) throw (CORBA::SystemException, OsbCorbaException);

        //TrunkGroup_ptr addTrunkGroup(
        //    TrunkGroupWriter& trkWriter
        //) throw (OsbCorbException);

        void delTrkGroup(
            const NetworkElementId& eid,
            const TrunkGroupId&     tid,
                  CORBA::Boolean    noWait
        ) throw (CORBA::SystemException, OsbCorbaException);

    private:
        NetworkManager_i& nmgri_;
    };                                  // class TrunkGroupMgr_i
}                                       // namespace OSB_CORBA
#endif                                  // #ifndef _NETWORKMANAGER_I_H_

---