IceGrid and IceStorm

1 files changed, 56 insertions, 66 deletions

diff --git a/cpp/src/IceGrid/RegistryI.h b/cpp/src/IceGrid/RegistryI.h
index 7589bdada8b..ca6f9d997d9 100644
--- a/cpp/src/IceGrid/RegistryI.h
+++ b/cpp/src/IceGrid/RegistryI.h
@@ -6,60 +6,47 @@
 #define ICE_GRID_REGISTRYI_H
 
 #include <IceUtil/Timer.h>
-#include <Ice/UniquePtr.h>
 #include <IceGrid/Registry.h>
 #include <IceGrid/Internal.h>
 #include <IceGrid/PlatformInfo.h>
 #include <IceGrid/ReplicaSessionManager.h>
 #include <IceGrid/PluginFacade.h>
-#include <Glacier2/PermissionsVerifierF.h>
+#include <Glacier2/PermissionsVerifier.h>
 #include <IceStorm/Service.h>
 
 namespace IceGrid
 {
 
+class AdminSessionFactory;
+class ClientSessionFactory;
 class Database;
-typedef IceUtil::Handle<Database> DatabasePtr;
-
-class WellKnownObjectsManager;
-typedef IceUtil::Handle<WellKnownObjectsManager> WellKnownObjectsManagerPtr;
-
-class TraceLevels;
-typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr;
-
 class ReapThread;
-typedef IceUtil::Handle<ReapThread> ReapThreadPtr;
-
 class SessionServantManager;
-typedef IceUtil::Handle<SessionServantManager> SessionServantManagerPtr;
-
-class ClientSessionFactory;
-typedef IceUtil::Handle<ClientSessionFactory> ClientSessionFactoryPtr;
-
-class AdminSessionFactory;
-typedef IceUtil::Handle<AdminSessionFactory> AdminSessionFactoryPtr;
+class TraceLevels;
+class WellKnownObjectsManager;
 
-std::string getInstanceName(const Ice::CommunicatorPtr&);
+std::string getInstanceName(const std::shared_ptr<Ice::Communicator>&);
 
-class RegistryI : public Registry
+class RegistryI : public Registry, public std::enable_shared_from_this<RegistryI>
 {
 public:
 
-    RegistryI(const Ice::CommunicatorPtr&, const TraceLevelsPtr&, bool, bool, const std::string&, const std::string&);
-    ~RegistryI();
+    RegistryI(const std::shared_ptr<Ice::Communicator>&, const std::shared_ptr<TraceLevels>&, bool, bool,
+              const std::string&, const std::string&);
+    virtual ~RegistryI() = default;
 
     bool start();
     bool startImpl();
     void stop();
 
-    virtual SessionPrx createSession(const std::string&, const std::string&, const Ice::Current&);
-    virtual AdminSessionPrx createAdminSession(const std::string&, const std::string&, const Ice::Current&);
+    std::shared_ptr<SessionPrx> createSession(std::string, std::string, const Ice::Current&) override;
+    std::shared_ptr<AdminSessionPrx> createAdminSession(std::string, std::string, const Ice::Current&) override;
 
-    virtual SessionPrx createSessionFromSecureConnection(const Ice::Current&);
-    virtual AdminSessionPrx createAdminSessionFromSecureConnection(const Ice::Current&);
+    std::shared_ptr<SessionPrx> createSessionFromSecureConnection(const Ice::Current&) override;
+    std::shared_ptr<AdminSessionPrx> createAdminSessionFromSecureConnection(const Ice::Current&) override;
 
-    virtual int getSessionTimeout(const Ice::Current&) const;
-    virtual int getACMTimeout(const Ice::Current&) const;
+    int getSessionTimeout(const Ice::Current&) const override;
+    int getACMTimeout(const Ice::Current&) const override;
 
     std::string getName() const;
     RegistryInfo getInfo() const;
@@ -71,64 +58,67 @@ public:
     std::string getNodeAdminCategory() const { return _instanceName + "-RegistryNodeAdminRouter"; }
     std::string getReplicaAdminCategory() const { return _instanceName + "-RegistryReplicaAdminRouter"; }
 
-    Ice::ObjectPrx createAdminCallbackProxy(const Ice::Identity&) const;
+    std::shared_ptr<Ice::ObjectPrx> createAdminCallbackProxy(const Ice::Identity&) const;
 
-    const Ice::ObjectAdapterPtr& getRegistryAdapter() { return _registryAdapter; }
+    const std::shared_ptr<Ice::ObjectAdapter>& getRegistryAdapter() { return _registryAdapter; }
 
-    Ice::LocatorPrx getLocator();
+    std::shared_ptr<Ice::LocatorPrx> getLocator();
 
 private:
 
     void setupLocatorRegistry();
-    LocatorPrx setupLocator(const RegistryPrx&, const QueryPrx&);
-    QueryPrx setupQuery();
-    RegistryPrx setupRegistry();
-    InternalRegistryPrx setupInternalRegistry();
+    std::shared_ptr<LocatorPrx> setupLocator(const std::shared_ptr<RegistryPrx>&, const std::shared_ptr<QueryPrx>&);
+    std::shared_ptr<QueryPrx> setupQuery();
+    std::shared_ptr<RegistryPrx> setupRegistry();
+    std::shared_ptr<InternalRegistryPrx> setupInternalRegistry();
     bool setupUserAccountMapper();
-    Ice::ObjectAdapterPtr setupClientSessionFactory(const LocatorPrx&);
-    Ice::ObjectAdapterPtr setupAdminSessionFactory(const Ice::ObjectPtr&, const Ice::ObjectPtr&,
-                                                   const Ice::ObjectPtr&, const LocatorPrx&);
-
-    Glacier2::PermissionsVerifierPrx getPermissionsVerifier(const LocatorPrx&, const std::string&);
-    Glacier2::SSLPermissionsVerifierPrx getSSLPermissionsVerifier(const LocatorPrx&, const std::string&);
-    Glacier2::SSLInfo getSSLInfo(const Ice::ConnectionPtr&, std::string&);
-
-    NodePrxSeq registerReplicas(const InternalRegistryPrx&, const NodePrxSeq&);
-    void registerNodes(const InternalRegistryPrx&, const NodePrxSeq&);
-
-    const Ice::CommunicatorPtr _communicator;
-    const TraceLevelsPtr _traceLevels;
+    std::shared_ptr<Ice::ObjectAdapter> setupClientSessionFactory(const std::shared_ptr<LocatorPrx>&);
+    std::shared_ptr<Ice::ObjectAdapter> setupAdminSessionFactory(const std::shared_ptr<Ice::Object>&,
+                                                                 const std::shared_ptr<Ice::Object>&,
+                                                                 const std::shared_ptr<Ice::Object>&,
+                                                                 const std::shared_ptr<LocatorPrx>&);
+
+    std::shared_ptr<Glacier2::PermissionsVerifierPrx> getPermissionsVerifier(const std::shared_ptr<LocatorPrx>&,
+                                                                             const std::string&);
+    std::shared_ptr<Glacier2::SSLPermissionsVerifierPrx> getSSLPermissionsVerifier(const std::shared_ptr<LocatorPrx>&,
+                                                                                   const std::string&);
+    Glacier2::SSLInfo getSSLInfo(const std::shared_ptr<Ice::Connection>&, std::string&);
+
+    NodePrxSeq registerReplicas(const std::shared_ptr<InternalRegistryPrx>&, const NodePrxSeq&);
+    void registerNodes(const std::shared_ptr<InternalRegistryPrx>&, const NodePrxSeq&);
+
+    const std::shared_ptr<Ice::Communicator> _communicator;
+    const std::shared_ptr<TraceLevels> _traceLevels;
     const bool _nowarn;
     const bool _readonly;
     const std::string _initFromReplica;
     const std::string _collocatedNodeName;
 
-    DatabasePtr _database;
-    Ice::ObjectAdapterPtr _clientAdapter;
-    Ice::ObjectAdapterPtr _serverAdapter;
-    Ice::ObjectAdapterPtr _registryAdapter;
-    WellKnownObjectsManagerPtr _wellKnownObjects;
+    std::shared_ptr<Database> _database;
+    std::shared_ptr<Ice::ObjectAdapter> _clientAdapter;
+    std::shared_ptr<Ice::ObjectAdapter> _serverAdapter;
+    std::shared_ptr<Ice::ObjectAdapter> _registryAdapter;
+    std::shared_ptr<WellKnownObjectsManager> _wellKnownObjects;
     std::string _instanceName;
     bool _master;
     std::string _replicaName;
-    ReapThreadPtr _reaper;
+    std::shared_ptr<ReapThread> _reaper;
     IceUtil::TimerPtr _timer;
-    SessionServantManagerPtr _servantManager;
-    int _sessionTimeout;
-    IceInternal::UniquePtr<ReplicaSessionManager> _session;
+    std::shared_ptr<SessionServantManager> _servantManager;
+    std::chrono::seconds _sessionTimeout;
+    std::unique_ptr<ReplicaSessionManager> _session;
     mutable PlatformInfo _platform;
 
-    ClientSessionFactoryPtr _clientSessionFactory;
-    Glacier2::PermissionsVerifierPrx _clientVerifier;
-    Glacier2::SSLPermissionsVerifierPrx _sslClientVerifier;
+    std::shared_ptr<ClientSessionFactory> _clientSessionFactory;
+    std::shared_ptr<Glacier2::PermissionsVerifierPrx> _clientVerifier;
+    std::shared_ptr<Glacier2::SSLPermissionsVerifierPrx> _sslClientVerifier;
 
-    AdminSessionFactoryPtr _adminSessionFactory;
-    Glacier2::PermissionsVerifierPrx _adminVerifier;
-    Glacier2::SSLPermissionsVerifierPrx _sslAdminVerifier;
+    std::shared_ptr<AdminSessionFactory> _adminSessionFactory;
+    std::shared_ptr<Glacier2::PermissionsVerifierPrx> _adminVerifier;
+    std::shared_ptr<Glacier2::SSLPermissionsVerifierPrx> _sslAdminVerifier;
 
-    IceStormInternal::ServicePtr _iceStorm;
+    std::shared_ptr<IceStormInternal::Service> _iceStorm;
 };
-typedef IceUtil::Handle<RegistryI> RegistryIPtr;
 
 }