void SubscriberImpl::startDeliveryWithFilter(const std::string& topic, const std::string& subscriberId, const MessageHandlerCallbackPtr& callback, const ClientMessageFilterPtr& filter) { if (0 == filter.get()) { throw NullMessageFilterException(); } if (0 == callback.get()) { throw NullMessageHandlerException(); } TopicSubscriber t(topic, subscriberId); // Get the subscriber channel handler SubscriberClientChannelHandlerPtr handler = channelManager->getSubscriptionChannelHandler(t); if (handler.get() == 0) { LOG4CXX_ERROR(logger, "Trying to start deliver on a non existant handler topic = " << topic << ", subscriber = " << subscriberId); throw NotSubscribedException(); } handler->startDelivery(t, callback, filter); }
/* static */ void SubscriberConsumeCallback::timerComplete(const SubscriberClientChannelHandlerPtr handler, const PubSubResponsePtr m, const boost::system::error_code& error) { if (error) { return; } handler->messageReceived(handler->getChannel(), m); }
bool SubscriberImpl::hasSubscription(const std::string& topic, const std::string& subscriberId) { TopicSubscriber ts(topic, subscriberId); // Get the subscriber channel handler SubscriberClientChannelHandlerPtr handler = channelManager->getSubscriptionChannelHandler(ts); if (!handler.get()) { return false; } return handler->hasSubscription(ts); }
void SubscriberImpl::stopDelivery(const std::string& topic, const std::string& subscriberId) { TopicSubscriber t(topic, subscriberId); boost::shared_lock<boost::shared_mutex> lock(topicsubscriber2handler_lock); SubscriberClientChannelHandlerPtr handler = topicsubscriber2handler[t]; if (handler.get() == 0) { LOG4CXX_ERROR(logger, "Trying to start deliver on a non existant handler topic = " << topic << ", subscriber = " << subscriberId); } handler->stopDelivery(); }
void SubscriberImpl::stopDelivery(const std::string& topic, const std::string& subscriberId) { TopicSubscriber t(topic, subscriberId); // Get the subscriber channel handler SubscriberClientChannelHandlerPtr handler = channelManager->getSubscriptionChannelHandler(t); if (handler.get() == 0) { LOG4CXX_ERROR(logger, "Trying to stop deliver on a non existant handler topic = " << topic << ", subscriber = " << subscriberId); throw NotSubscribedException(); } handler->stopDelivery(t); }
void SubscriberImpl::closeSubscription(const std::string& topic, const std::string& subscriberId) { LOG4CXX_DEBUG(logger, "closeSubscription (" << topic << ", " << subscriberId << ")"); TopicSubscriber t(topic, subscriberId); SubscriberClientChannelHandlerPtr handler; { boost::lock_guard<boost::shared_mutex> lock(topicsubscriber2handler_lock); handler = topicsubscriber2handler[t]; topicsubscriber2handler.erase(t); } if (handler.get() != 0) { handler->close(); } }
void SubscriberImpl::doSubscribe(const DuplexChannelPtr& channel, const PubSubDataPtr& data, const SubscriberClientChannelHandlerPtr& handler) { channel->storeTransaction(data); OperationCallbackPtr writecb(new SubscriberWriteCallback(client, data)); channel->writeRequest(data->getRequest(), writecb); boost::lock_guard<boost::shared_mutex> lock(topicsubscriber2handler_lock); TopicSubscriber t(data->getTopic(), data->getSubscriberId()); SubscriberClientChannelHandlerPtr oldhandler = topicsubscriber2handler[t]; if (oldhandler != NULL) { oldhandler->handoverDelivery(handler); } topicsubscriber2handler[t] = handler; LOG4CXX_DEBUG(logger, "Set topic subscriber for topic(" << data->getTopic() << ") subscriberId(" << data->getSubscriberId() << ") to " << handler.get() << " topicsubscriber2topic(" << &topicsubscriber2handler << ")"); }
void SubscriberImpl::consume(const std::string& topic, const std::string& subscriberId, const MessageSeqId& messageSeqId) { TopicSubscriber t(topic, subscriberId); // Get the subscriber channel handler SubscriberClientChannelHandlerPtr handler = channelManager->getSubscriptionChannelHandler(t); if (handler.get() == 0) { LOG4CXX_ERROR(logger, "Cannot consume. No subscription channel handler found for topic (" << topic << ") subscriberId(" << subscriberId << ")."); return; } handler->consume(t, messageSeqId); }
/*static*/ void SubscriberClientChannelHandler::reconnectTimerComplete(const SubscriberClientChannelHandlerPtr handler, const DuplexChannelPtr channel, const std::exception e, const boost::system::error_code& error) { if (error) { return; } handler->should_wait = false; handler->channelDisconnected(channel, e); }
void SubscriberImpl::consume(const std::string& topic, const std::string& subscriberId, const MessageSeqId& messageSeqId) { TopicSubscriber t(topic, subscriberId); boost::shared_lock<boost::shared_mutex> lock(topicsubscriber2handler_lock); SubscriberClientChannelHandlerPtr handler = topicsubscriber2handler[t]; if (handler.get() == 0) { LOG4CXX_ERROR(logger, "Cannot consume. Bad handler for topic(" << topic << ") subscriberId(" << subscriberId << ") topicsubscriber2topic(" << &topicsubscriber2handler << ")"); return; } DuplexChannelPtr channel = handler->getChannel(); if (channel.get() == 0) { LOG4CXX_ERROR(logger, "Trying to consume a message on a topic/subscriber pair that don't have a channel. Something fishy going on. Topic: " << topic << " SubscriberId: " << subscriberId << " MessageSeqId: " << messageSeqId.localcomponent()); } PubSubDataPtr data = PubSubData::forConsumeRequest(client->counter().next(), subscriberId, topic, messageSeqId); OperationCallbackPtr writecb(new ConsumeWriteCallback(client, data)); channel->writeRequest(data->getRequest(), writecb); }
void SubscriberClientChannelHandler::handoverDelivery(const SubscriberClientChannelHandlerPtr& newHandler) { LOG4CXX_DEBUG(logger, "Messages in queue " << queue.size()); MessageHandlerCallbackPtr handler = this->handler; stopDelivery(); // resets old handler newHandler->startDelivery(handler); }