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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
// **********************************************************************
//
// 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_SERVER_I_H
#define ICE_GRID_SERVER_I_H
#include <IceUtil/Mutex.h>
#include <Freeze/EvictorF.h>
#include <IceGrid/Activator.h>
#include <IceGrid/WaitQueue.h>
#include <IceGrid/Internal.h>
#ifndef _WIN32
# include <sys/types.h> // for uid_t, gid_t
#endif
namespace IceGrid
{
class NodeI;
typedef IceUtil::Handle<NodeI> NodeIPtr;
class ServerAdapterI;
typedef IceUtil::Handle<ServerAdapterI> ServerAdapterIPtr;
class ServerCommand;
typedef IceUtil::Handle<ServerCommand> ServerCommandPtr;
class DestroyCommand;
typedef IceUtil::Handle<DestroyCommand> DestroyCommandPtr;
class StopCommand;
typedef IceUtil::Handle<StopCommand> StopCommandPtr;
class StartCommand;
typedef IceUtil::Handle<StartCommand> StartCommandPtr;
class PatchCommand;
typedef IceUtil::Handle<PatchCommand> PatchCommandPtr;
class LoadCommand;
typedef IceUtil::Handle<LoadCommand> LoadCommandPtr;
class ServerI : public Server, public IceUtil::Monitor<IceUtil::Mutex>
{
public:
enum InternalServerState
{
Inactive,
Activating,
WaitForActivation,
ActivationTimeout,
Active,
Deactivating,
DeactivatingWaitForProcess,
Destroying,
Destroyed,
Loading,
Patching
};
enum ServerActivation
{
Always,
Session,
OnDemand,
Manual,
Disabled
};
ServerI(const NodeIPtr&, const ServerPrx&, const std::string&, const std::string&, int);
virtual ~ServerI();
virtual void start_async(const AMD_Server_startPtr&, const ::Ice::Current& = Ice::Current());
virtual void stop_async(const AMD_Server_stopPtr&, const ::Ice::Current& = Ice::Current());
virtual void sendSignal(const std::string&, const ::Ice::Current&);
virtual void writeMessage(const std::string&, Ice::Int, const ::Ice::Current&);
virtual ServerState getState(const ::Ice::Current& = Ice::Current()) const;
virtual Ice::Int getPid(const ::Ice::Current& = Ice::Current()) const;
virtual void setEnabled(bool, const ::Ice::Current&);
virtual bool isEnabled(const ::Ice::Current& = Ice::Current()) const;
virtual void setProcess_async(const AMD_Server_setProcessPtr&, const ::Ice::ProcessPrx&, const ::Ice::Current&);
std::string getApplication() const;
bool canActivateOnDemand() const;
const std::string& getId() const;
DistributionDescriptor getDistribution() const;
bool hasApplicationDistribution() const;
void getDynamicInfo(ServerDynamicInfoSeq&, AdapterDynamicInfoSeq&) const;
void start(ServerActivation, const AMD_Server_startPtr& = AMD_Server_startPtr());
void load(const AMD_Node_loadServerPtr&, const std::string&, const ServerDescriptorPtr&, const std::string&);
void destroy(const AMD_Node_destroyServerPtr&);
bool startPatch(bool);
bool waitForPatch();
void finishPatch();
void adapterActivated(const std::string&);
void adapterDeactivated(const std::string&);
void activationFailed(bool);
void deactivationFailed();
void activate();
void kill();
void deactivate();
void update();
void destroy();
void terminated(const std::string&, int);
private:
void updateImpl(const std::string&, const ServerDescriptorPtr&, const std::string&);
void checkActivation();
void checkDestroyed();
void disableOnFailure();
void enableAfterFailure(bool);
void setState(InternalServerState, const std::string& = std::string());
ServerCommandPtr nextCommand();
void setStateNoSync(InternalServerState, const std::string& = std::string());
std::string addAdapter(const AdapterDescriptor&, const CommunicatorDescriptorPtr&);
void updateConfigFile(const std::string&, const CommunicatorDescriptorPtr&);
void updateDbEnv(const std::string&, const DbEnvDescriptor&);
PropertyDescriptor createProperty(const std::string&, const std::string& = std::string());
void createOrUpdateDirectory(const std::string&);
ServerState toServerState(InternalServerState) const;
ServerActivation toServerActivation(const std::string&) const;
ServerDynamicInfo getDynamicInfo() const;
const NodeIPtr _node;
const ServerPrx _this;
const std::string _id;
const Ice::Int _waitTime;
const std::string _serverDir;
const int _disableOnFailure;
std::string _application;
ServerDescriptorPtr _desc;
std::string _sessionId;
#ifndef _WIN32
uid_t _uid;
gid_t _gid;
#endif
InternalServerState _state;
ServerActivation _activation;
int _activationTimeout;
int _deactivationTimeout;
typedef std::map<std::string, ServerAdapterIPtr> ServerAdapterDict;
ServerAdapterDict _adapters;
bool _processRegistered;
Ice::ProcessPrx _process;
std::set<std::string> _activeAdapters;
IceUtil::Time _failureTime;
ServerActivation _previousActivation;
WaitItemPtr _timer;
DestroyCommandPtr _destroy;
StopCommandPtr _stop;
LoadCommandPtr _load;
PatchCommandPtr _patch;
StartCommandPtr _start;
int _pid;
};
typedef IceUtil::Handle<ServerI> ServerIPtr;
class ServerCommand : public IceUtil::SimpleShared
{
public:
ServerCommand(const ServerIPtr&);
virtual void execute() = 0;
virtual ServerI::InternalServerState nextState() = 0;
protected:
const ServerIPtr _server;
};
typedef IceUtil::Handle<ServerCommand> ServerCommandPtr;
class TimedServerCommand : public ServerCommand
{
public:
TimedServerCommand(const ServerIPtr&, const WaitQueuePtr&, int);
virtual void timeout(bool) = 0;
void startTimer();
void stopTimer();
private:
WaitQueuePtr _waitQueue;
WaitItemPtr _timer;
int _timeout;
};
typedef IceUtil::Handle<TimedServerCommand> TimedServerCommandPtr;
}
#endif
|
