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
|
// **********************************************************************
//
// Copyright (c) 2003-2009 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.
//
// **********************************************************************
#include <Ice/Application.h>
#include <Ice/Locator.h>
#include <BackendI.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 : virtual public 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 : virtual public Locator
{
public:
ServerLocatorI(const BackendPtr& backend, const ObjectAdapterPtr& adapter) :
_backend(backend),
_adapter(adapter),
_registryPrx(
LocatorRegistryPrx::uncheckedCast(
adapter->add(new ServerLocatorRegistry, _adapter->getCommunicator()->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& id, const Current& current) const
{
cb->ice_response(_adapter->createDirectProxy(_adapter->getCommunicator()->stringToIdentity("dummy")));
}
virtual LocatorRegistryPrx
getRegistry(const Current&) const
{
return _registryPrx;
}
private:
const BackendPtr _backend;
const ObjectAdapterPtr _adapter;
const LocatorRegistryPrx _registryPrx;
};
class ServantLocatorI : virtual public 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 Application
{
public:
virtual int run(int, char*[]);
};
int
main(int argc, char* argv[])
{
BackendServer app;
return app.main(argc, argv);
}
int
BackendServer::run(int argc, char* argv[])
{
string endpoints =
communicator()->getProperties()->getPropertyWithDefault("BackendAdapter.Endpoints",
"tcp -p 12010 -t 20000:ssl -p 12011 -t 20000");
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, communicator()->stringToIdentity("locator"));
adapter->addServantLocator(new ServantLocatorI(backend), "");
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
|
