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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
// **********************************************************************
//
// Copyright (c) 2003-2009 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.
//
// **********************************************************************
public final class RemoteEvictorI extends Test._RemoteEvictorDisp
{
static class Initializer implements Freeze.ServantInitializer
{
public void
initialize(Ice.ObjectAdapter adapter, Ice.Identity ident, String facet, Ice.Object servant)
{
if(servant instanceof AccountI)
{
AccountI account = (AccountI)servant;
account.init((Freeze.TransactionalEvictor)_evictor);
}
else if(facet.length() == 0)
{
ServantI servantImpl = (ServantI) ((Test._ServantTie) servant).ice_delegate();
servantImpl.init(_remoteEvictor, _evictor);
}
else
{
ServantI servantImpl = (ServantI) ((Test._FacetTie) servant).ice_delegate();
servantImpl.init(_remoteEvictor, _evictor);
}
}
void init(RemoteEvictorI remoteEvictor, Freeze.Evictor evictor)
{
_remoteEvictor = remoteEvictor;
_evictor = evictor;
}
private RemoteEvictorI _remoteEvictor;
private Freeze.Evictor _evictor;
}
RemoteEvictorI(Ice.ObjectAdapter adapter, String envName, String category, boolean transactional)
{
_adapter = adapter;
_envName = envName;
_category = category;
//
// NOTE: COMPILERBUG: The timeout here is required for MacOS X. It shouldn't be too low since
// some operations can take some time to complete on slow machines.
//
_evictorAdapter = _adapter.getCommunicator().
createObjectAdapterWithEndpoints(Ice.Util.generateUUID(), "default -t 60000");
Initializer initializer = new Initializer();
if(transactional)
{
_evictor = Freeze.Util.createTransactionalEvictor(_evictorAdapter, envName, category, null, initializer, null, true);
}
else
{
_evictor = Freeze.Util.createBackgroundSaveEvictor(_evictorAdapter, envName, category, initializer, null, true);
}
initializer.init(this, _evictor);
_evictorAdapter.addServantLocator(_evictor, category);
_evictorAdapter.activate();
}
public void
setSize(int size, Ice.Current current)
{
_evictor.setSize(size);
}
public Test.ServantPrx
createServant(String id, int value, Ice.Current current)
throws Test.AlreadyRegisteredException, Test.EvictorDeactivatedException
{
Ice.Identity ident = new Ice.Identity();
ident.category = _category;
ident.name = id;
Test._ServantTie tie = new Test._ServantTie();
tie.ice_delegate(new ServantI(tie, this, _evictor, value));
try
{
return Test.ServantPrxHelper.uncheckedCast(_evictor.add(tie, ident));
}
catch(Ice.AlreadyRegisteredException e)
{
throw new Test.AlreadyRegisteredException();
}
catch(Ice.ObjectAdapterDeactivatedException e)
{
throw new Test.EvictorDeactivatedException();
}
catch(Freeze.EvictorDeactivatedException e)
{
throw new Test.EvictorDeactivatedException();
}
catch(Ice.LocalException e)
{
System.out.println("Throwing " + e.toString());
throw e;
}
}
public Test.ServantPrx
getServant(String id, Ice.Current current)
{
Ice.Identity ident = new Ice.Identity();
ident.category = _category;
ident.name = id;
return Test.ServantPrxHelper.uncheckedCast(_evictorAdapter.createProxy(ident));
}
public void
saveNow(Ice.Current current)
{
if(_evictor instanceof Freeze.BackgroundSaveEvictor)
{
_evictor.getIterator("", 1);
}
//
// Otherwise everything is always saved
//
}
public void
deactivate(Ice.Current current)
{
_evictorAdapter.destroy();
_adapter.remove(_adapter.getCommunicator().stringToIdentity(_category));
}
public void
destroyAllServants(String facet, Ice.Current current)
{
//
// Only for test purpose: don't use such a small value in
// a real application!
//
int batchSize = 2;
Freeze.EvictorIterator p = _evictor.getIterator(facet, batchSize);
while(p.hasNext())
{
_evictor.remove((Ice.Identity) p.next());
}
}
final public String
envName()
{
return _envName;
}
private Ice.ObjectAdapter _adapter;
private final String _envName;
private String _category;
private Freeze.Evictor _evictor;
private Ice.ObjectAdapter _evictorAdapter;
}
|
