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
|
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
#include <Ice/Ice.h>
#include <BackendI.h>
#include <TestHelper.h>
using namespace std;
using namespace Ice;
using namespace Test;
//
// Dummy ServerLocatorRegistry, ServerLocator and ServantLocator. For
// simplicity, we essentially 'alias' all possible requests to a single
// object adapter and a single servant.
//
class ServerLocatorRegistry : public virtual LocatorRegistry
{
public:
virtual void
setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb, const string&,
const ObjectPrx&, const Current&)
{
cb->ice_response();
}
virtual void
setReplicatedAdapterDirectProxy_async(const AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr& cb,
const string&, const string&, const ObjectPrx&, const Current&)
{
cb->ice_response();
}
virtual void
setServerProcessProxy_async(const AMD_LocatorRegistry_setServerProcessProxyPtr& cb,
const string&, const ProcessPrx&, const Current&)
{
cb->ice_response();
}
};
class ServerLocatorI : public virtual Locator
{
public:
ServerLocatorI(const BackendPtr& backend, const ObjectAdapterPtr& adapter) :
_backend(backend),
_adapter(adapter),
_registryPrx(
LocatorRegistryPrx::uncheckedCast(
adapter->add(new ServerLocatorRegistry, Ice::stringToIdentity("registry"))))
{
}
virtual void
findObjectById_async(const AMD_Locator_findObjectByIdPtr& cb, const Identity& id, const Current&) const
{
cb->ice_response(_adapter->createProxy(id));
}
virtual void
findAdapterById_async(const AMD_Locator_findAdapterByIdPtr& cb, const string&, const Current&) const
{
cb->ice_response(_adapter->createDirectProxy(stringToIdentity("dummy")));
}
virtual LocatorRegistryPrx
getRegistry(const Current&) const
{
return _registryPrx;
}
private:
const BackendPtr _backend;
const ObjectAdapterPtr _adapter;
const LocatorRegistryPrx _registryPrx;
};
class ServantLocatorI : public virtual ServantLocator
{
public:
ServantLocatorI(const BackendPtr& backend) :
_backend(backend)
{
}
virtual ObjectPtr locate(const Current&, LocalObjectPtr&)
{
return _backend;
}
virtual void finished(const Current&, const ObjectPtr&, const LocalObjectPtr&)
{
}
virtual void deactivate(const string&)
{
}
private:
const BackendPtr _backend;
};
class BackendServer : public Test::TestHelper
{
public:
void run(int, char**);
};
void
BackendServer::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
string endpoints = communicator->getProperties()->getPropertyWithDefault("BackendAdapter.Endpoints",
"tcp -p 12010:ssl -p 12011");
communicator->getProperties()->setProperty("BackendAdapter.Endpoints", endpoints);
ObjectAdapterPtr adapter = communicator->createObjectAdapter("BackendAdapter");
BackendPtr backend = new BackendI;
Ice::LocatorPtr locator = new ServerLocatorI(backend, adapter);
adapter->add(locator, Ice::stringToIdentity("locator"));
adapter->addServantLocator(new ServantLocatorI(backend), "");
adapter->activate();
communicator->waitForShutdown();
}
DEFINE_TEST(BackendServer)
|
