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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
// -*- C++ -*-
//
// $Id$
#include "RT_ORBInitializer.h"
ACE_RCSID (TAO, RT_ORBInitializer, "$Id$")
#define TAO_RTCORBA_SAFE_INCLUDE
#include "tao/RTCORBA/RTCORBAC.h"
#undef TAO_RTCORBA_SAFE_INCLUDE
#include "RT_Policy_i.h"
#include "RT_Protocols_Hooks.h"
#include "Priority_Mapping_Manager.h"
#include "tao/Exception.h"
#include "tao/ORB_Core.h"
#include "tao/ORBInitInfo.h"
#include "RT_ORB_Loader.h"
#include "RT_Stub_Factory.h"
#include "RT_Endpoint_Selector_Factory.h"
#include "Linear_Priority_Mapping.h"
#include "Direct_Priority_Mapping.h"
#include "RT_ORB.h"
#include "RT_Current.h"
#include "RT_Thread_Lane_Resources_Manager.h"
#include "ace/Service_Repository.h"
#include "ace/Svc_Conf.h"
static const char *rt_poa_factory_name = "TAO_RT_POA";
static const char *rt_poa_factory_directive = "dynamic TAO_RT_POA Service_Object * TAO_RTPortableServer:_make_TAO_RT_Object_Adapter_Factory()";
TAO_RT_ORBInitializer::TAO_RT_ORBInitializer (int priority_mapping_type,
long sched_policy,
long scope_policy)
: priority_mapping_type_ (priority_mapping_type),
sched_policy_ (sched_policy),
scope_policy_ (scope_policy)
{
}
void
TAO_RT_ORBInitializer::pre_init (
PortableInterceptor::ORBInitInfo_ptr info
TAO_ENV_ARG_DECL)
ACE_THROW_SPEC ((CORBA::SystemException))
{
TAO_ENV_ARG_DEFN;
//
// Register all of the RT related services.
//
// Set the name of the Protocol_Hooks to be RT_Protocols_Hooks.
TAO_ORB_Core::set_protocols_hooks ("RT_Protocols_Hooks");
ACE_Service_Config::process_directive (ace_svc_desc_TAO_RT_Protocols_Hooks);
// Set the name of the stub factory to be RT_Stub_Factory.
TAO_ORB_Core::set_stub_factory ("RT_Stub_Factory");
ACE_Service_Config::process_directive (ace_svc_desc_TAO_RT_Stub_Factory);
// Set the name of the stub factory to be RT_Stub_Factory.
TAO_ORB_Core::set_endpoint_selector_factory ("RT_Endpoint_Selector_Factory");
ACE_Service_Config::process_directive (ace_svc_desc_RT_Endpoint_Selector_Factory);
// Set the name of the thread lane resources manager to be RT_Thread_Lane_Resources_Manager.
TAO_ORB_Core::set_thread_lane_resources_manager_factory ("RT_Thread_Lane_Resources_Manager_Factory");
ACE_Service_Config::process_directive (ace_svc_desc_TAO_RT_Thread_Lane_Resources_Manager_Factory);
// If the application resolves the root POA, make sure we load the RT POA.
TAO_ORB_Core::set_poa_factory (rt_poa_factory_name,
rt_poa_factory_directive);
// Sets the client_protocol policy.
TAO_RT_Protocols_Hooks::set_client_protocols_hook
(TAO_ClientProtocolPolicy::hook);
// Sets the server_protocol policy.
TAO_RT_Protocols_Hooks::set_server_protocols_hook
(TAO_ServerProtocolPolicy::hook);
// Conversion.
long sched_policy = ACE_SCHED_OTHER;
if (this->sched_policy_ == THR_SCHED_FIFO)
sched_policy = ACE_SCHED_FIFO;
else if (this->sched_policy_ == THR_SCHED_RR)
sched_policy = ACE_SCHED_RR;
// Create the initial priority mapping instance.
TAO_Priority_Mapping *pm;
switch (this->priority_mapping_type_)
{
case TAO_PRIORITY_MAPPING_LINEAR:
ACE_NEW (pm,
TAO_Linear_Priority_Mapping (sched_policy));
break;
default:
case TAO_PRIORITY_MAPPING_DIRECT:
ACE_NEW (pm,
TAO_Direct_Priority_Mapping (sched_policy));
break;
}
// Set the Priority_Mapping_Manager
TAO_Priority_Mapping_Manager *manager = 0;
ACE_NEW_THROW_EX (manager,
TAO_Priority_Mapping_Manager (pm),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO_DEFAULT_MINOR_CODE,
ENOMEM),
CORBA::COMPLETED_NO));
ACE_CHECK;
TAO_Priority_Mapping_Manager_var safe_manager = manager;
info->register_initial_reference ("PriorityMappingManager",
manager,
ACE_TRY_ENV);
ACE_CHECK;
// @@ This is busted. TAO_ORBInitInfo should do proper reference
// counting.
// Narrow to a TAO_ORBInitInfo object to get access to the
// orb_core() TAO extension.
TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info,
ACE_TRY_ENV);
ACE_CHECK;
if (CORBA::is_nil (tao_info.in ()))
{
if (TAO_debug_level > 0)
ACE_ERROR ((LM_ERROR,
"(%P|%t) Security_ORBInitializer::pre_init:\n"
"(%P|%t) Unable to narrow "
"\"PortableInterceptor::ORBInitInfo_ptr\" to\n"
"(%P|%t) \"TAO_ORBInitInfo *.\"\n"));
ACE_THROW (CORBA::INTERNAL ());
}
// Create the RT_ORB.
CORBA::Object_ptr rt_orb = CORBA::Object::_nil ();
ACE_NEW_THROW_EX (rt_orb,
TAO_RT_ORB (tao_info->orb_core ()),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO_DEFAULT_MINOR_CODE,
ENOMEM),
CORBA::COMPLETED_NO));
ACE_CHECK;
CORBA::Object_var safe_rt_orb = rt_orb;
info->register_initial_reference (TAO_OBJID_RTORB,
rt_orb,
ACE_TRY_ENV);
ACE_CHECK;
// Create the RT_Current.
CORBA::Object_ptr current;
ACE_NEW_THROW_EX (current,
TAO_RT_Current (tao_info->orb_core ()),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO_DEFAULT_MINOR_CODE,
ENOMEM),
CORBA::COMPLETED_NO));
ACE_CHECK;
CORBA::Object_var safe_rt_current = current;
info->register_initial_reference (TAO_OBJID_RTCURRENT,
current,
ACE_TRY_ENV);
ACE_CHECK;
tao_info->orb_core ()->orb_params ()->scope_policy (this->scope_policy_);
tao_info->orb_core ()->orb_params ()->sched_policy (this->sched_policy_);
}
void
TAO_RT_ORBInitializer::post_init (
PortableInterceptor::ORBInitInfo_ptr info
TAO_ENV_ARG_DECL)
ACE_THROW_SPEC ((CORBA::SystemException))
{
TAO_ENV_ARG_DEFN;
this->register_policy_factories (info,
ACE_TRY_ENV);
ACE_CHECK;
}
void
TAO_RT_ORBInitializer::register_policy_factories (
PortableInterceptor::ORBInitInfo_ptr info,
CORBA::Environment &ACE_TRY_ENV)
{
// Register the RTCORBA policy factories.
// The RTCORBA policy factory is stateless and reentrant, so share a
// single instance between all ORBs.
PortableInterceptor::PolicyFactory_ptr policy_factory =
&(this->policy_factory_);
// Bind the same policy factory to all RTCORBA related policy
// types since a single policy factory is used to create each of
// the different types of RTCORBA policies.
CORBA::PolicyType type = RTCORBA::PRIORITY_MODEL_POLICY_TYPE;
info->register_policy_factory (type,
policy_factory,
ACE_TRY_ENV);
ACE_CHECK;
type = RTCORBA::PRIORITY_BANDED_CONNECTION_POLICY_TYPE;
info->register_policy_factory (type,
policy_factory,
ACE_TRY_ENV);
ACE_CHECK;
type = RTCORBA::CLIENT_PROTOCOL_POLICY_TYPE;
info->register_policy_factory (type,
policy_factory,
ACE_TRY_ENV);
ACE_CHECK;
}
|
