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
|
// -*- IDL -*-
//=============================================================================
/**
* @file CosLoadBalancing.idl
*
* $Id$
*
* @author Object Management Group
*/
//=============================================================================
#ifndef COSLOADBALANCING_IDL
#define COSLOADBALANCING_IDL
//#include "tao/PortableInterceptor.pidl"
#include "PortableGroup.idl"
#include "orb.idl"
#pragma prefix "omg.org"
/**
* @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
{
typedef PortableGroup::Location Location;
typedef PortableGroup::Properties Properties;
/// Types used for obtaining and/or reporting loads
typedef unsigned long LoadId;
struct Load {
LoadId id;
float value;
};
typedef sequence<Load> LoadList;
// typedef unsigned short MonitoringStyle;
// const MonitoringStyle PULL = 0;
// const MonitoringStyle PUSH = 1;
// // const MonitoringStyle NOT_MONITORED = 2;
// typedef unsigned short MonitoringGranularity;
// const MonitoringGranularity MEMB = 0;
// const MonitoringGranularity LOC = 1;
// const MonitoringGranularity LOC_AND_TYPE = 2;
// typedef unsigned short ClientBinding;
// const ClientBinding PER_SESSION = 0;
// const ClientBinding PER_REQUEST = 1;
// const ClientBinding ON_DEMAND = 2;
// typedef unsigned short BalancingPolicy;
// const BalancingPolicy NON_ADAPTIVE = 0;
// const BalancingPolicy ADAPTIVE = 1;
exception MonitorAlreadyPresent {};
exception LocationNotFound {};
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 (LocationNotFound);
// Get loads, if any, at the given location. Load balancing
// strategies may use this method to query loads at specific
// locations.
LoadList get_loads (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 LoadManager load_manager);
// The given loads at the given location should no longer be
// considered when performing load analysis.
void location_removed (in PortableGroup::Location the_location)
raises (LocationNotFound);
};
struct StrategyInfo
{
Properties props;
};
interface LoadAlert
{
// Forward requests back to the load manager via the object group
// reference.
void alert (in Object object_group);
// 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
{
// void register_load_notifier (in LoadNotifier load_notifier);
// LoadNotifier get_load_notifier ()
// raises (PortableGroup::InterfaceNotFound);
// For the PUSH load monitoring style.
void push_loads (in PortableGroup::Location the_location,
in LoadList loads);
// The following load monitor methods are only used for the PULL
// load monitoring style.
void register_load_monitor (in LoadMonitor load_monitor,
in PortableGroup::Location the_location)
raises (MonitorAlreadyPresent);
LoadMonitor get_load_monitor (in PortableGroup::Location the_location)
raises (LocationNotFound);
void remove_load_monitor (in PortableGroup::Location the_location)
raises (LocationNotFound);
void register_alerter (in PortableGroup::ObjectGroup object_group,
in PortableGroup::Location the_location,
in Object alert)
raises (LocationNotFound);
};
// /// It's not clear this interface is needed for the Load Balancer.
// interface LoadNotifier
// {
// };
};
#pragma prefix ""
#endif /* COSLOADBALANCING_IDL */
|
