blob: 32da8474dddd3cd8da66a34ef509a7cd067ea677 (
plain)
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
|
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
#include <Ice/Ice.h>
#include <IceStorm/IceStorm.h>
#include <Single.h>
#include <Controller.h>
#include <TestHelper.h>
using namespace std;
using namespace Ice;
using namespace IceStorm;
using namespace Test;
class ControllerI final : public Controller
{
public:
void stop(const Ice::Current& c) override
{
c.adapter->getCommunicator()->shutdown();
}
};
class PublishThread final
{
public:
explicit PublishThread(shared_ptr<SinglePrx> single) :
_single(std::move(single)),
_published(0),
_destroy(false)
{
}
void run()
{
while(true)
{
{
lock_guard<mutex> log(_mutex);
if(_destroy)
{
cout << _published << endl;
break;
}
}
try
{
_single->event(_published);
this_thread::sleep_for(1ms);
}
catch(const Ice::UnknownException&)
{
// This is expected if we publish to a replica that is
// going down.
continue;
}
++_published;
}
}
void destroy()
{
lock_guard<mutex> log(_mutex);
_destroy = true;
}
private:
const shared_ptr<SinglePrx> _single;
int _published;
bool _destroy;
mutex _mutex;
};
class Publisher final : public Test::TestHelper
{
public:
void run(int, char**) override;
};
void
Publisher::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
auto properties = communicator->getProperties();
string managerProxy = properties->getProperty("IceStormAdmin.TopicManager.Default");
if(managerProxy.empty())
{
ostringstream os;
os << argv[0] << ": property `IceStormAdmin.TopicManager.Default' is not set";
throw invalid_argument(os.str());
}
auto manager = checkedCast<IceStorm::TopicManagerPrx>(
communicator->stringToProxy(managerProxy));
if(!manager)
{
ostringstream os;
os << argv[0] << ": `" << managerProxy << "' is not running";
throw invalid_argument(os.str());
}
auto topic = manager->retrieve("single");
assert(topic);
//
// Get a publisher object, create a twoway proxy, disable
// connection caching and then cast to a Single object.
//
auto single = uncheckedCast<SinglePrx>(topic->getPublisher()->ice_twoway()->ice_connectionCached(false));
auto adapter = communicator->createObjectAdapterWithEndpoints("ControllerAdapter", "tcp");
auto controller = adapter->addWithUUID(make_shared<ControllerI>());
adapter->activate();
cout << communicator->proxyToString(controller) << endl;
PublishThread pt(move(single));
auto fut = std::async(launch::async, [&pt]{ pt.run(); });
communicator->waitForShutdown();
pt.destroy();
fut.get();
}
DEFINE_TEST(Publisher)
|
