blob: 11f12386aa92910cc9a6d5392bd667aa865c1993 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// **********************************************************************
//
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#ifndef ICE_GRID_NODE_SESSION_MANAGER_H
#define ICE_GRID_NODE_SESSION_MANAGER_H
#include <IceUtil/Handle.h>
#include <IceUtil/Mutex.h>
#include <IceUtil/Monitor.h>
#include <IceGrid/SessionManager.h>
#include <IceGrid/Query.h>
#include <IceGrid/Internal.h>
#include <set>
namespace IceGrid
{
class NodeI;
typedef IceUtil::Handle<NodeI> NodeIPtr;
class NodeSessionKeepAliveThread : public SessionKeepAliveThread<NodeSessionPrx>
{
public:
NodeSessionKeepAliveThread(const InternalRegistryPrx&, const NodeIPtr&, const std::vector<QueryPrx>&);
virtual NodeSessionPrx createSession(InternalRegistryPrx&, IceUtil::Time&);
virtual void destroySession(const NodeSessionPrx&);
virtual bool keepAlive(const NodeSessionPrx&);
std::string getName() const { return _name; }
protected:
virtual NodeSessionPrx createSessionImpl(const InternalRegistryPrx&, IceUtil::Time&);
const NodeIPtr _node;
const std::string _name;
const std::vector<QueryPrx> _queryObjects;
};
typedef IceUtil::Handle<NodeSessionKeepAliveThread> NodeSessionKeepAliveThreadPtr;
class NodeSessionManager : public IceUtil::Monitor<IceUtil::Mutex>
{
public:
NodeSessionManager();
void create(const NodeIPtr&);
void create(const InternalRegistryPrx&);
void activate();
bool waitForCreate();
void terminate();
void destroy();
void replicaInit(const InternalRegistryPrxSeq&);
void replicaAdded(const InternalRegistryPrx&);
void replicaRemoved(const InternalRegistryPrx&);
NodeSessionPrx getMasterNodeSession() const { return _thread->getSession(); }
private:
NodeSessionKeepAliveThreadPtr addReplicaSession(const InternalRegistryPrx&);
void reapReplicas();
void syncServers(const NodeSessionPrx&);
class Thread : public NodeSessionKeepAliveThread
{
public:
Thread(NodeSessionManager& manager) :
NodeSessionKeepAliveThread(manager._master, manager._node, manager._queryObjects),
_manager(manager)
{
}
virtual NodeSessionPrx
createSession(InternalRegistryPrx& master, IceUtil::Time& timeout)
{
NodeSessionPrx session = NodeSessionKeepAliveThread::createSession(master, timeout);
_manager.createdSession(session);
_manager.reapReplicas();
return session;
}
virtual void
destroySession(const NodeSessionPrx& session)
{
NodeSessionKeepAliveThread::destroySession(session);
_manager.reapReplicas();
}
virtual bool
keepAlive(const NodeSessionPrx& session)
{
bool alive = NodeSessionKeepAliveThread::keepAlive(session);
_manager.reapReplicas();
return alive;
}
private:
NodeSessionManager& _manager;
};
typedef IceUtil::Handle<Thread> ThreadPtr;
friend class Thread;
void createdSession(const NodeSessionPrx&);
const NodeIPtr _node;
ThreadPtr _thread;
std::vector<QueryPrx> _queryObjects;
InternalRegistryPrx _master;
unsigned long _serial;
bool _destroyed;
bool _activated;
typedef std::map<Ice::Identity, NodeSessionKeepAliveThreadPtr> NodeSessionMap;
NodeSessionMap _sessions;
std::set<Ice::Identity> _replicas;
};
}
#endif
|
