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
|
// -*- IDL -*-
//=============================================================================
/**
* @file CosLoadBalancing.idl
*
* $Id$
*
* @author Object Management Group
*/
//=============================================================================
#ifndef COSLOADBALANCING_IDL
#define COSLOADBALANCING_IDL
#include "PortableGroup.idl"
#include "orb.idl"
/**
* @class CosLoadBalancing
*
* @brief This module defines the interfaces and data types used in
* TAO's Load Balancing service.
* @par
* TAO's Load Balancer manages distribution of requests to replicas of
* a given Object in an effort to ensure that the applications/hosts
* pointed to by the Object reference are as equally loaded as
* possible, i.e. load balanced.
* @par
* The definition of 'load' is application specific, for example, some
* applications may choose to load balance access to multiple
* dedicated lines, or separate network interfaces, as well as more
* traditional load balancing metrics, such as CPU or power load.
*/
module CosLoadBalancing
{
typeprefix CosLoadBalancing "tao.lb";
const IOP::ServiceId LOAD_MANAGED = 123456; // @todo TBA by OMG
typedef PortableGroup::Location Location;
typedef PortableGroup::Properties Properties;
// Types used for obtaining and/or reporting loads
typedef unsigned long LoadId;
// OMG defined LoadId constants.
const LoadId LoadAverage = 0;
const LoadId Disk = 1;
const LoadId Memory = 2;
const LoadId Network = 3;
const LoadId RequestsPerSecond = 4;
struct Load {
LoadId id;
float value;
};
typedef sequence<Load> LoadList;
exception MonitorAlreadyPresent {};
exception LocationNotFound {};
exception LoadAlertNotFound {};
exception LoadAlertAlreadyPresent {};
exception LoadAlertNotAdded {};
exception StrategyNotAdaptive {};
interface LoadManager;
interface Strategy
{
readonly attribute string name;
Properties get_properties ();
// Report loads at given location to the LoadManager.
void push_loads (in PortableGroup::Location the_location,
in LoadList loads)
raises (StrategyNotAdaptive);
// Get loads, if any, at the given location. Load balancing
// strategies may use this method to query loads at specific
// locations. Returned loads are the effective loads computed by
// the Strategy, as opposed to the raw loads maintained by the
// LoadManager.
LoadList get_loads (in LoadManager load_manager,
in PortableGroup::Location the_location)
raises (LocationNotFound);
// Return the next member from the given object group which will
// requests will be forward to.
Object next_member (in PortableGroup::ObjectGroup object_group,
in LoadManager load_manager)
raises (PortableGroup::ObjectGroupNotFound,
PortableGroup::MemberNotFound);
// Ask the Strategy to analyze loads, and enable or disable alerts
// at object group members residing at appropriate locations.
oneway void analyze_loads (in PortableGroup::ObjectGroup object_group,
in LoadManager load_manager);
// The loads at the given location should no longer be considered
// when performing load analysis.
// void location_removed (in PortableGroup::Location the_location)
// raises (LocationNotFound);
};
typedef Strategy CustomStrategy;
// Property value for built-in load balancing Strategy.
struct StrategyInfo
{
string name;
Properties props;
};
interface LoadAlert
{
// Forward requests back to the load manager via the object group
// reference.
void enable_alert ();
// Stop forwarding requests, and begin accepting them again.
void disable_alert ();
};
// Interface that all load monitors must implement.
interface LoadMonitor
{
// Retrieve the location at which the LoadMonitor resides.
readonly attribute Location the_location;
// Retrieve the current load at the location LoadMonitor resides.
readonly attribute LoadList loads;
};
// Specification of LoadManager Interface
interface LoadManager
: PortableGroup::PropertyManager,
PortableGroup::ObjectGroupManager,
PortableGroup::GenericFactory
{
// For the PUSH load monitoring style.
void push_loads (in PortableGroup::Location the_location,
in LoadList loads);
// Return the raw loads at the given location, as opposed to the
// potentially different effective loads returned by the
// Strategy::get_loads() method.
LoadList get_loads (in PortableGroup::Location the_location)
raises (LocationNotFound);
// Inform member at given location of load alert condition.
void enable_alert (in PortableGroup::Location the_location)
raises (LoadAlertNotFound);
// Inform member at given location that load alert condition has
// passed.
void disable_alert (in PortableGroup::Location the_location)
raises (LoadAlertNotFound);
// Register a LoadAlert object for the member at the given
// location.
void register_load_alert (in PortableGroup::Location the_location,
in LoadAlert load_alert)
raises (LoadAlertAlreadyPresent,
LoadAlertNotAdded);
// Retrieve the LoadAlert object for the member at the given
// location.
LoadAlert get_load_alert (in PortableGroup::Location the_location)
raises (LoadAlertNotFound);
// Remove (de-register) the LoadAlert object for the member at the
// given location.
void remove_load_alert (in PortableGroup::Location the_location)
raises (LoadAlertNotFound);
// The following load monitor methods are only used for the PULL
// load monitoring style.
// Register a LoadMonitor object for "pull" monitoring of the
// given location.
void register_load_monitor (in PortableGroup::Location the_location,
in LoadMonitor load_monitor)
raises (MonitorAlreadyPresent);
// Retrieve the LoadMonitor object for the given location.
LoadMonitor get_load_monitor (in PortableGroup::Location the_location)
raises (LocationNotFound);
// Remove (de-register) the LoadMonitor object for the given
// location.
void remove_load_monitor (in PortableGroup::Location the_location)
raises (LocationNotFound);
};
};
#endif /* COSLOADBALANCING_IDL */
|
