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
136
137
138
139
140
141
|
// **********************************************************************
//
// Copyright (c) 2003-2006 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 ICEGRID_SESSIONI_H
#define ICEGRID_SESSIONI_H
#include <IceUtil/Mutex.h>
#include <IceGrid/Session.h>
#include <IceGrid/SessionServantLocatorI.h>
namespace IceGrid
{
class Database;
typedef IceUtil::Handle<Database> DatabasePtr;
class TraceLevels;
typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr;
class AllocationRequest;
typedef IceUtil::Handle<AllocationRequest> AllocationRequestPtr;
class Allocatable;
typedef IceUtil::Handle<Allocatable> AllocatablePtr;
class WaitQueue;
typedef IceUtil::Handle<WaitQueue> WaitQueuePtr;
class SessionI;
typedef IceUtil::Handle<SessionI> SessionIPtr;
class BaseSessionI : public IceUtil::Mutex
{
public:
virtual ~BaseSessionI();
virtual void keepAlive(const Ice::Current&);
virtual int getTimeout(const Ice::Current&) const;
virtual void destroy(const Ice::Current&);
IceUtil::Time timestamp() const;
void setServantLocator(const SessionServantLocatorIPtr&);
protected:
BaseSessionI(const std::string&, const std::string&, const DatabasePtr&, int);
const std::string _id;
const std::string _prefix;
const int _timeout;
const TraceLevelsPtr _traceLevels;
const DatabasePtr _database;
const SessionServantLocatorIPtr _servantLocator;
bool _destroyed;
IceUtil::Time _timestamp;
};
class SessionI : virtual public Session, public BaseSessionI
{
public:
SessionI(const std::string&, const DatabasePtr&, int, const WaitQueuePtr&, const Glacier2::SessionControlPrx&);
SessionI(const std::string&, const DatabasePtr&, int, const WaitQueuePtr&, const Ice::ConnectionPtr&);
virtual ~SessionI();
virtual void keepAlive(const Ice::Current& current) { BaseSessionI::keepAlive(current); }
virtual int getTimeout(const Ice::Current& current) const { return BaseSessionI::getTimeout(current); }
virtual void allocateObjectById_async(const AMD_Session_allocateObjectByIdPtr&, const Ice::Identity&,
const Ice::Current&);
virtual void allocateObjectByType_async(const AMD_Session_allocateObjectByTypePtr&, const std::string&,
const Ice::Current&);
virtual void releaseObject(const Ice::Identity&, const Ice::Current&);
virtual void setAllocationTimeout(int, const Ice::Current&);
virtual void destroy(const Ice::Current&);
int getAllocationTimeout() const;
const WaitQueuePtr& getWaitQueue() const { return _waitQueue; }
const std::string& getId() const { return _id; }
Glacier2::SessionControlPrx getSessionControl() const { return _sessionControl; }
bool addAllocationRequest(const AllocationRequestPtr&);
void removeAllocationRequest(const AllocationRequestPtr&);
bool addAllocation(const AllocatablePtr&);
void removeAllocation(const AllocatablePtr&);
protected:
const WaitQueuePtr _waitQueue;
const Glacier2::SessionControlPrx _sessionControl;
const Ice::ConnectionPtr _connection;
int _allocationTimeout;
std::set<AllocationRequestPtr> _requests;
std::set<AllocatablePtr> _allocations;
};
class ClientSessionManagerI : virtual public Glacier2::SessionManager
{
public:
ClientSessionManagerI(const DatabasePtr&, int, const WaitQueuePtr&);
virtual Glacier2::SessionPrx create(const std::string&, const Glacier2::SessionControlPrx&, const Ice::Current&);
SessionIPtr create(const std::string&, const Glacier2::SessionControlPrx&);
private:
const DatabasePtr _database;
const int _timeout;
const WaitQueuePtr _waitQueue;
};
typedef IceUtil::Handle<ClientSessionManagerI> ClientSessionManagerIPtr;
class ClientSSLSessionManagerI : virtual public Glacier2::SSLSessionManager
{
public:
ClientSSLSessionManagerI(const DatabasePtr&, int, const WaitQueuePtr&);
virtual Glacier2::SessionPrx create(const Glacier2::SSLInfo&, const Glacier2::SessionControlPrx&,
const Ice::Current&);
private:
const DatabasePtr _database;
const int _timeout;
const WaitQueuePtr _waitQueue;
};
typedef IceUtil::Handle<ClientSSLSessionManagerI> ClientSSLSessionManagerIPtr;
};
#endif
|
