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
|
// **********************************************************************
//
// 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 ICE_GRID_OBJECTCACHE_H
#define ICE_GRID_OBJECTCACHE_H
#include <IceUtil/Mutex.h>
#include <IceUtil/Shared.h>
#include <Ice/CommunicatorF.h>
#include <IceGrid/Cache.h>
#include <IceGrid/Internal.h>
#include <IceGrid/Query.h>
#include <IceGrid/Allocatable.h>
namespace IceGrid
{
class ObjectCache;
class ServerEntry;
typedef IceUtil::Handle<ServerEntry> ServerEntryPtr;
class ObjectEntry : public Allocatable
{
public:
ObjectEntry(Cache<Ice::Identity, ObjectEntry>&, const Ice::Identity&);
void set(const AllocatablePtr&, const std::string&, const ObjectInfo&);
Ice::ObjectPrx getProxy() const;
std::string getType() const;
std::string getApplication() const;
const ObjectInfo& getObjectInfo() const;
bool canRemove();
virtual bool release(const SessionIPtr&);
virtual void allocated(const SessionIPtr&);
virtual void released(const SessionIPtr&);
private:
ObjectCache& _cache;
std::string _application;
ObjectInfo _info;
};
typedef IceUtil::Handle<ObjectEntry> ObjectEntryPtr;
class ObjectAllocationRequest : public AllocationRequest
{
public:
ObjectAllocationRequest(const SessionIPtr& session) : AllocationRequest(session) { }
virtual void response(const Ice::ObjectPrx&) = 0;
virtual void exception(const AllocationException&) = 0;
private:
virtual void allocated(const AllocatablePtr& allocatable)
{
response(ObjectEntryPtr::dynamicCast(allocatable)->getProxy());
}
virtual void canceled(const AllocationException& ex)
{
exception(ex);
}
};
typedef IceUtil::Handle<ObjectAllocationRequest> ObjectAllocationRequestPtr;
class AdapterCache;
class ObjectCache : public Cache<Ice::Identity, ObjectEntry>
{
public:
ObjectCache(const Ice::CommunicatorPtr&, AdapterCache&);
void add(const AllocatablePtr&, const std::string&, const std::string&, const std::string&,
const ObjectDescriptor&);
ObjectEntryPtr get(const Ice::Identity&) const;
ObjectEntryPtr remove(const Ice::Identity&);
void allocateByType(const std::string&, const ObjectAllocationRequestPtr&);
void allocateByTypeOnLeastLoadedNode(const std::string&, const ObjectAllocationRequestPtr&, LoadSample);
void released(const ObjectEntryPtr&);
Ice::ObjectProxySeq getObjectsByType(const std::string&);
ObjectInfoSeq getAll(const std::string&);
ObjectInfoSeq getAllByType(const std::string&);
private:
class TypeEntry
{
public:
TypeEntry(ObjectCache&);
void add(const Ice::ObjectPrx&);
bool remove(const Ice::ObjectPrx&);
void addAllocationRequest(const ObjectAllocationRequestPtr&);
void released(const ObjectEntryPtr&);
const Ice::ObjectProxySeq& getObjects() const { return _objects; }
private:
ObjectCache& _cache;
Ice::ObjectProxySeq _objects;
std::list<ObjectAllocationRequestPtr> _requests;
};
const Ice::CommunicatorPtr _communicator;
AdapterCache& _adapterCache;
std::map<std::string, TypeEntry> _types;
std::map<std::string, std::vector<Ice::Identity> > _allocatablesByType;
static std::pointer_to_unary_function<int, int> _rand;
};
};
#endif
|
