virtual void init(std::shared_ptr<DBusStubAdapter> instance) {
DBusStubAdapter::init(instance);
std::shared_ptr<StubAdapterType> stubAdapter = std::dynamic_pointer_cast<StubAdapterType>(instance);
- remoteEventHandler_ = stub_->initStubAdapter(stubAdapter);
+ remoteEventHandler_ = stub_.lock()->initStubAdapter(stubAdapter);
}
virtual void deinit() {
bool dbusMessageHandled = false;
//To prevent the destruction of the stub whilst still handling a message
- auto stubSafety = stub_;
+ auto stubSafety = stub_.lock();
if (stubSafety && foundInterfaceMemberHandler) {
StubDispatcher* stubDispatcher = static_cast<StubDispatcher*>(findIterator->second);
dbusMessageHandled = stubDispatcher->dispatchDBusMessage(dbusMessage, stubSafety, *this);
virtual const StubDispatcherTable& getStubDispatcherTable() = 0;
- std::shared_ptr<_StubClass> stub_;
+ std::weak_ptr<_StubClass> stub_;
RemoteEventHandlerType* remoteEventHandler_;
};
}
void noPartnerCleanup(void* data) {
- std::cout << "Cleanup" << std::endl;
promise3.set_value(true);
}
bool isTestStubAdapterRegistered_ = runtime_->getServicePublisher()->registerService<commonapi::tests::TestInterfaceStub>(stubDefault_, commonApiAddress, serviceFactory_);
ASSERT_TRUE(isTestStubAdapterRegistered_);
- usleep(500000);
+ usleep(100000);
}
void registerExtendedStub() {
bool isExtendedStubAdapterRegistered_ = runtime_->getServicePublisher()->registerService<commonapi::tests::ExtendedInterfaceStub>(stubExtended_, commonApiAddressExtended, serviceFactory_);
ASSERT_TRUE(isExtendedStubAdapterRegistered_);
- usleep(500000);
+ usleep(100000);
}
void deregisterTestStub() {
auto extendedProxy = serviceFactory_->buildProxy<commonapi::tests::ExtendedInterfaceProxy>(commonApiAddressExtended);
// give the proxy time to become available
- for (uint32_t i = 0; !extendedProxy->isAvailable() && i < 500; ++i) {
+ for (uint32_t i = 0; !extendedProxy->isAvailable() && i < 200; ++i) {
usleep(20 * 1000);
}
ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
wasCalled = true;
});
- usleep(500000);
+ usleep(100000);
EXPECT_TRUE(wasCalled);
deregisterExtendedStub();
auto extendedProxy = serviceFactory_->buildProxy<commonapi::tests::ExtendedInterfaceProxy>(commonApiAddressExtended);
- for (uint32_t i = 0; !extendedProxy->isAvailable() && i < 500; ++i) {
+ for (uint32_t i = 0; !extendedProxy->isAvailable() && i < 200; ++i) {
usleep(20 * 1000);
}
EXPECT_TRUE(extendedProxy->isAvailable());
ASSERT_EQ(callStatus, CommonAPI::CallStatus::SUCCESS);
wasCalled = true;
});
- usleep(500000);
+ usleep(100000);
EXPECT_TRUE(wasCalled);
deregisterExtendedStub();
auto extendedProxy = serviceFactory_->buildProxy<commonapi::tests::TestInterfaceProxy>(commonApiAddressExtended);
- for (uint32_t i = 0; !extendedProxy->isAvailable() && i < 800; ++i) {
+ for (uint32_t i = 0; !extendedProxy->isAvailable() && i < 200; ++i) {
usleep(20 * 1000);
}
EXPECT_TRUE(extendedProxy->isAvailable());
double speedRatio = durationWithColdCache / durationWithHotCache;
- std::cout << "cold " << durationWithColdCache << "\n";
- std::cout << "hot " << durationWithHotCache << "\n";
-
EXPECT_GE(speedRatio, 100);
}
ExtendedInterfaceDBusStubAdapterInternal::~ExtendedInterfaceDBusStubAdapterInternal() {
deactivateManagedInstances();
ExtendedInterfaceDBusStubAdapterHelper::deinit();
- ExtendedInterfaceDBusStubAdapterHelper::stub_.reset();
}
void ExtendedInterfaceDBusStubAdapterInternal::deactivateManagedInstances() {
TestInterfaceDBusStubAdapterInternal::~TestInterfaceDBusStubAdapterInternal() {
deactivateManagedInstances();
TestInterfaceDBusStubAdapterHelper::deinit();
- TestInterfaceDBusStubAdapterHelper::stub_.reset();
}
void TestInterfaceDBusStubAdapterInternal::deactivateManagedInstances() {
}
void TestInterfaceDBusStubAdapterInternal::subscribeForTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
- bool ok = stub_->onTestSelectiveBroadcastSelectiveSubscriptionRequested(clientId);
+ auto stub = stub_.lock();
+ bool ok = stub->onTestSelectiveBroadcastSelectiveSubscriptionRequested(clientId);
if (ok) {
subscribersForTestSelectiveBroadcastSelective_->insert(clientId);
- stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+ stub->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
success = true;
} else {
success = false;
void TestInterfaceDBusStubAdapterInternal::unsubscribeFromTestSelectiveBroadcastSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
subscribersForTestSelectiveBroadcastSelective_->erase(clientId);
- stub_->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+ auto stub = stub_.lock();
+ stub->onTestSelectiveBroadcastSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
}
std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceDBusStubAdapterInternal::getSubscribersForTestSelectiveBroadcastSelective() {
}
void TestInterfaceDBusStubAdapterInternal::subscribeForTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId, bool& success) {
- bool ok = stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(clientId);
+ auto stub = stub_.lock();
+ bool ok = stub->onTestBroadcastWithOutArgsSelectiveSubscriptionRequested(clientId);
if (ok) {
subscribersForTestBroadcastWithOutArgsSelective_->insert(clientId);
- stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
+ stub->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::SUBSCRIBED);
success = true;
} else {
success = false;
void TestInterfaceDBusStubAdapterInternal::unsubscribeFromTestBroadcastWithOutArgsSelective(const std::shared_ptr<CommonAPI::ClientId> clientId) {
subscribersForTestBroadcastWithOutArgsSelective_->erase(clientId);
- stub_->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
+ auto stub = stub_.lock();
+ stub->onTestBroadcastWithOutArgsSelectiveSubscriptionChanged(clientId, CommonAPI::SelectiveBroadcastSubscriptionEvent::UNSUBSCRIBED);
}
std::shared_ptr<CommonAPI::ClientIdList> const TestInterfaceDBusStubAdapterInternal::getSubscribersForTestBroadcastWithOutArgsSelective() {
BranchInterfaceDBusStubAdapterInternal::~BranchInterfaceDBusStubAdapterInternal() {
deactivateManagedInstances();
BranchInterfaceDBusStubAdapterHelper::deinit();
- BranchInterfaceDBusStubAdapterHelper::stub_.reset();
}
void BranchInterfaceDBusStubAdapterInternal::deactivateManagedInstances() {
LeafInterfaceDBusStubAdapterInternal::~LeafInterfaceDBusStubAdapterInternal() {
deactivateManagedInstances();
LeafInterfaceDBusStubAdapterHelper::deinit();
- LeafInterfaceDBusStubAdapterHelper::stub_.reset();
}
void LeafInterfaceDBusStubAdapterInternal::deactivateManagedInstances() {
RootInterfaceDBusStubAdapterInternal::~RootInterfaceDBusStubAdapterInternal() {
deactivateManagedInstances();
RootInterfaceDBusStubAdapterHelper::deinit();
- RootInterfaceDBusStubAdapterHelper::stub_.reset();
}
void RootInterfaceDBusStubAdapterInternal::deactivateManagedInstances() {
SecondRootDBusStubAdapterInternal::~SecondRootDBusStubAdapterInternal() {
deactivateManagedInstances();
SecondRootDBusStubAdapterHelper::deinit();
- SecondRootDBusStubAdapterHelper::stub_.reset();
}
void SecondRootDBusStubAdapterInternal::deactivateManagedInstances() {