void Searcher::publishCharacters(const std::vector<Filesystem::AbsolutePath> & files){ PaintownUtil::Thread::ScopedLock scoped(subscriptionLock); for (vector<Subscriber*>::iterator it = subscriptions.begin(); it != subscriptions.end(); it++){ Subscriber * who = *it; who->receiveCharacters(files); } }
void AgpsStateMachine::sendRsrcRequest(AGpsStatusValue action) const { Subscriber* s = NULL; Notification notification(Notification::BROADCAST_ACTIVE); linked_list_search(mSubscribers, (void**)&s, hasSubscriber, (void*)¬ification, false); if ((NULL == s) == (GPS_RELEASE_AGPS_DATA_CONN == action)) { AGpsStatus nifRequest; nifRequest.size = sizeof(nifRequest); nifRequest.type = mType; nifRequest.status = action; if (s == NULL) { nifRequest.ipaddr = INADDR_NONE; memset(&nifRequest.addr, 0, sizeof(nifRequest.addr)); nifRequest.ssid[0] = '\0'; nifRequest.password[0] = '\0'; } else { s->setIPAddresses(nifRequest.ipaddr, (char *)&((struct sockaddr_in6*)&(nifRequest.addr))->sin6_addr); s->setWifiInfo(nifRequest.ssid, nifRequest.password); } CALLBACK_LOG_CALLFLOW("agps_cb", %s, loc_get_agps_status_name(action)); (*mServicer)(&nifRequest); }
int Server::sub(struct evhttp_request *req, Subscriber::Type sub_type){ if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){ evhttp_send_reply(req, 405, "Method Not Allowed", NULL); return 0; } bufferevent_enable(req->evcon->bufev, EV_READ); HttpQuery query(req); int seq = query.get_int("seq", 0); int noop = query.get_int("noop", 0); const char *cb = query.get_str("cb", DEFAULT_JSONP_CALLBACK); const char *token = query.get_str("token", ""); std::string cname = query.get_str("cname", ""); Channel *channel = this->get_channel_by_name(cname); if(!channel && this->auth == AUTH_NONE){ channel = this->new_channel(cname); if(!channel){ evhttp_send_reply(req, 429, "Too Many Channels", NULL); return 0; } } if(!channel || (this->auth == AUTH_TOKEN && channel->token != token)){ channel->error_token_error(req, cb, token); return 0; } if(channel->subs.size >= ServerConfig::max_subscribers_per_channel){ channel->error_too_many_subscribers(req, cb); return 0; } if(channel->idle < ServerConfig::channel_idles){ channel->idle = ServerConfig::channel_idles; } // send buffered messages if(!channel->msg_list.empty() && channel->seq_next != seq){ //channel->send_old_msgs(req, seq, cb); //return 0; } Subscriber *sub = sub_pool.alloc(); sub->req = req; sub->serv = this; sub->type = sub_type; sub->idle = 0; sub->seq = seq; sub->noop_seq = noop; sub->callback = cb; channel->add_subscriber(sub); subscribers ++; log_debug("%s:%d sub %s, subs: %d, channels: %d", req->remote_host, req->remote_port, channel->name.c_str(), channel->subs.size, used_channels.size); sub->start(); return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { Subscriber subscriber (argc, argv); subscriber.run (); } catch (Subscriber::InitError& ex) { std::string& msg = reinterpret_cast<std::string&>(ex); std::cerr << "Unexpected initialization Error: " << msg.c_str() << std::endl; return -1; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( "ERROR: Subscriber caught exception"); return -1; } return 0; }
int Server::sub(struct evhttp_request *req, Subscriber::Type sub_type){ if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){ evhttp_send_reply(req, 405, "Method Not Allowed", NULL); return 0; } HttpQuery query(req); int seq = query.get_int("seq", 0); int noop = query.get_int("noop", 0); const char *cb = query.get_str("cb", ""); const char *token = query.get_str("token", ""); std::string cname = query.get_str("cname", ""); Channel *channel = this->get_channel_by_name(cname); if(!channel && this->auth == AUTH_NONE){ channel = this->new_channel(cname); if(!channel){ //evhttp_send_reply(req, 429, "Too many channels", NULL); Subscriber::send_error_reply(sub_type, req, cb, cname, "429", "Too many channels"); return 0; } } if(!channel || (this->auth == AUTH_TOKEN && channel->token != token)){ //evhttp_send_reply(req, 401, "Token error", NULL); log_info("%s:%d sub %s, token: %s, token error!", req->remote_host, req->remote_port, cname.c_str(), token); Subscriber::send_error_reply(sub_type, req, cb, cname, "401", "Token error"); return 0; } if(channel->subs.size >= ServerConfig::max_subscribers_per_channel){ //evhttp_send_reply(req, 429, "Too many subscribers", NULL); Subscriber::send_error_reply(sub_type, req, cb, cname, "429", "Too many subscribers"); return 0; } if(channel->idle < ServerConfig::channel_idles){ channel->idle = ServerConfig::channel_idles; } Subscriber *sub = new Subscriber(); sub->req = req; sub->type = sub_type; sub->idle = 0; sub->seq_next = seq; sub->seq_noop = noop; sub->callback = cb; channel->add_subscriber(sub); subscribers ++; log_debug("%s:%d sub %s, seq: %d, subs: %d", req->remote_host, req->remote_port, channel->name.c_str(), seq, channel->subs.size); sub->start(); return 0; }
int main() { Frame *f = new Frame(1); Subscriber s; s.process(f); f = new SuperFrame(1, 2); f = new AnotherFrame(1, 2, 3); s.process(f); return 0; }
int main(int argc, char** argv) { QCoreApplication app(argc, argv); Subscriber subscriber; subscriber.connectToHost(); Publisher publisher; publisher.connectToHost(); return app.exec(); }
/** * Construct a new subscriber, generate a keypairt and set the required attributes * @param string node_name name of the subscriber * @param string port the port number of the subscriber * @return Subscriber */ Subscriber* SecurityServer::addSubscriber(bytestring client_name, std::string port) { RSAKeyPair rsa_key_pair = this->generateKeyPair(RSAKeyPair::KeyLength); this->clients[client_name] = rsa_key_pair.getPublic(); Subscriber *sub = new Subscriber(client_name, port, rsa_key_pair); sub->setServer(this->key_pair.getPublic()); return sub; }
void Publisher::publish( Subscriber* pSub, EventNotification* pEvent ) { Subscriber* pSubscriber = pSub; // HandleEvent() returns a pointer to the next chained Subscriber, if any. while ( pSubscriber ) { pSubscriber = pSubscriber->HandleEvent( pEvent ); } }
AgpsState* AgpsReleasedState::onRsrcEvent(AgpsRsrcStatus event, void* data) { LOC_LOGD("AgpsReleasedState::onRsrcEvent; event:%d\n", (int)event); if (mStateMachine->hasSubscribers()) { LOC_LOGE("Error: %s subscriber list not empty!!!", whoami()); // I don't know how to recover from it. I am adding this rather // for debugging purpose. } AgpsState* nextState = this; switch (event) { case RSRC_SUBSCRIBE: { // no notification until we get RSRC_GRANTED // but we need to add subscriber to the list mStateMachine->addSubscriber((Subscriber*)data); // request from connecivity service for NIF //The if condition is added so that if the data call setup fails //for DS State Machine, we want to retry in released state. //for AGps State Machine, sendRsrcRequest() will always return success if(!mStateMachine->sendRsrcRequest(GPS_REQUEST_AGPS_DATA_CONN)) { // move the state to PENDING nextState = mPendingState; } } break; case RSRC_UNSUBSCRIBE: { // the list should really be empty, nothing to remove. // but we might as well just tell the client it is // unsubscribed. False tolerance, right? Subscriber* subscriber = (Subscriber*) data; Notification notification(subscriber, event, false); subscriber->notifyRsrcStatus(notification); } // break; case RSRC_GRANTED: case RSRC_RELEASED: case RSRC_DENIED: default: LOC_LOGW("%s: unrecognized event %d", whoami(), event); // no state change. break; } LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", whoami(), nextState->whoami(), event); return nextState; }
typename std::enable_if<!std::is_same<Subscriber, subscriber<T>>::value, void>::type on_subscribe(Subscriber o) const { static_assert(is_subscriber<Subscriber>::value, "on_subscribe must be passed a subscriber."); ts->on_subscribe(o.as_dynamic()); }
code handle(std::istream& stream, Subscriber subscriber) const { const auto message_ptr = std::make_shared<Message>(); const bool parsed = message_ptr->from_data(stream); const code ec(parsed ? error::success : error::bad_stream); subscriber->do_relay(ec, message_ptr); return ec; }
void TcpDuplexConnection::setInput(Subscriber<Payload>& inputSubscriber) { inputSubscriber_.reset(&inputSubscriber); auto* subscription = new MemoryMixin<TcpSubscriptionBase>(*this); inputSubscriber.onSubscribe(*subscription); socket_->setReadCB(this); };
int init(const TransferPriority priority) { int res = allocation_pub_.init(priority); if (res < 0) { return res; } allocation_pub_.setTxTimeout(MonotonicDuration::fromMSec(Allocation::FOLLOWUP_TIMEOUT_MS)); res = allocation_sub_.start(AllocationCallback(this, &AllocationRequestManager::handleAllocation)); if (res < 0) { return res; } allocation_sub_.allowAnonymousTransfers(); return 0; }
int init() { int res = allocation_pub_.init(); if (res < 0) { return res; } (void)allocation_pub_.setPriority(TransferPriorityLow); allocation_pub_.setTxTimeout(MonotonicDuration::fromMSec(Allocation::DEFAULT_REQUEST_PERIOD_MS)); res = allocation_sub_.start(AllocationCallback(this, &AllocationRequestManager::handleAllocation)); if (res < 0) { return res; } allocation_sub_.allowAnonymousTransfers(); return 0; }
void Publisher::notify(UpdateData *what) { // Kill old subscribers first. if (this->level == 0) { for(vector<Subscriber*>::iterator it = this->removableSubscribers.begin(); it != this->removableSubscribers.end(); it++) { this->subscribers.remove(*it); } this->removableSubscribers.clear(); } // Notify the rest! this->level++; for(list<Subscriber*>::iterator it = this->subscribers.begin(); it != this->subscribers.end(); it++) { Subscriber *subscriber = *it; if (subscriber != 0) { subscriber->update(this, what); } } this->level--; }
/***************************************************************************************************************************************** Start of main ********************************************************************************************************************************************/ int main(int argc, char** argv){ //init ros::init(argc, argv, "joystick_to_twist_node"); ROS_INFO_ONCE("ROS is initialized"); Subscriber sub; //set frame rate for ROS while loop ros::Rate loop_rate(ROS_FRAME_RATE); while(ros::ok()) { sub.sendValue(); ROS_INFO_ONCE("first value is send"); ros::spinOnce(); loop_rate.sleep(); } return 0; }
void CpiSubscriptionManager::Run() { for (;;) { Wait(); Subscriber* subscriber = iFree.Read(); iLock.Wait(); CpiSubscription* subscription = iList.front(); iList.front() = NULL; iList.pop_front(); iLock.Signal(); subscriber->Subscribe(subscription); iLock.Wait(); TBool shutdownSignal = ReadyForShutdown(); iLock.Signal(); if (shutdownSignal) { iShutdownSem.Signal(); } } }
void on_subscribe(const Subscriber& s) const { typedef Subscriber output_type; struct state_type : public std::enable_shared_from_this<state_type> , public values { state_type(const values& i, const output_type& oarg) : values(i) , mode_value(mode::taking) , out(oarg) { } typename mode::type mode_value; output_type out; }; // take a copy of the values for each subscription auto state = std::make_shared<state_type>(initial, s); composite_subscription source_lifetime; s.add(source_lifetime); state->source.subscribe( // split subscription lifetime source_lifetime, // on_next [state, source_lifetime](T t) { if (state->mode_value < mode::triggered) { if (--state->count > 0) { state->out.on_next(t); } else { state->mode_value = mode::triggered; state->out.on_next(t); // must shutdown source before signaling completion source_lifetime.unsubscribe(); state->out.on_completed(); } } }, // on_error [state](std::exception_ptr e) { state->mode_value = mode::errored; state->out.on_error(e); }, // on_completed [state]() { state->mode_value = mode::stopped; state->out.on_completed(); } ); }
void on_subscribe(Subscriber o) const { static_assert(is_subscriber<Subscriber>::value, "subscribe must be passed a subscriber"); // creates a worker whose lifetime is the same as this subscription auto coordinator = initial.coordination.create_coordinator(o.get_subscription()); auto controller = coordinator.get_worker(); auto counter = std::make_shared<long>(0); auto producer = [o, counter](const rxsc::schedulable&) { // send next value o.on_next(++(*counter)); }; auto selectedProducer = on_exception( [&](){return coordinator.act(producer);}, o); if (selectedProducer.empty()) { return; } controller.schedule_periodically(initial.initial, initial.period, selectedProducer.get()); }
// Connection callback that unsubscribes from the tracker if no one is subscribed. void connectCallback(ros::Subscriber &sub_msg, ros::NodeHandle &n, string gp_topic, string img_topic, Subscriber<GroundPlane> &sub_gp, Subscriber<CameraInfo> &sub_cam, image_transport::SubscriberFilter &sub_col, image_transport::ImageTransport &it){ if(!pub_message.getNumSubscribers() && !pub_result_image.getNumSubscribers() && !pub_detected_persons.getNumSubscribers()) { ROS_DEBUG("HOG: No subscribers. Unsubscribing."); sub_msg.shutdown(); sub_gp.unsubscribe(); sub_cam.unsubscribe(); sub_col.unsubscribe(); } else { ROS_DEBUG("HOG: New subscribers. Subscribing."); if(strcmp(gp_topic.c_str(), "") == 0) { sub_msg = n.subscribe(img_topic.c_str(), 1, &imageCallback); } sub_cam.subscribe(); sub_gp.subscribe(); sub_col.subscribe(it,sub_col.getTopic().c_str(),1); } }
int init() { int res = get_node_info_client_.init(); if (res < 0) { return res; } get_node_info_client_.setCallback( GetNodeInfoResponseCallback(this, &NodeDiscoverer::handleGetNodeInfoResponse)); res = node_status_sub_.start(NodeStatusCallback(this, &NodeDiscoverer::handleNodeStatus)); if (res < 0) { return res; } // Note: the timer starts ad-hoc from the node status callback, not here. return 0; }
void subscribeThread(Subscriber<std_msgs::UInt32>& sub, bool& failed) { resetThreadAllocInfo(); const int count = 10000; int my_count = 0; int32_t last = -1; while (true) { std_msgs::UInt32ConstPtr msg = sub.poll(); if (msg) { if (last >= (int32_t)msg->data) { ROS_ERROR_STREAM("Thread " << boost::this_thread::get_id() << " last is greater than msg " << last << " >= " << msg->data); failed = true; break; } last = msg->data; ++my_count; //ROS_INFO_STREAM("Thread " << boost::this_thread::get_id() << " " << my_count); } if (my_count >= count) { break; } ros::WallDuration(0.0001).sleep(); } if (getThreadAllocInfo().total_ops > 0UL) { ROS_ERROR_STREAM("Thread " << boost::this_thread::get_id() << " performed " << getThreadAllocInfo().total_ops << " memory operations (malloc/free/etc.)"); failed = true; } }
Subscriber::Subscriber(const Subscriber& other) { this->subscriber_name = other.getName(); sub_msg_buf = new MessageBuffer(); sub_msg_buf->copyFrom(*other.getBuffer()); }
void on_subscribe(Subscriber scbr) const { static_assert(is_subscriber<Subscriber>::value, "subscribe must be passed a subscriber"); typedef Subscriber output_type; struct merge_state_type : public std::enable_shared_from_this<merge_state_type> , public values { merge_state_type(values i, coordinator_type coor, output_type oarg) : values(i) , source(i.source_operator) , pendingCompletions(0) , coordinator(std::move(coor)) , out(std::move(oarg)) { } observable<source_value_type, source_operator_type> source; // on_completed on the output must wait until all the // subscriptions have received on_completed int pendingCompletions; coordinator_type coordinator; output_type out; }; auto coordinator = initial.coordination.create_coordinator(scbr.get_subscription()); // take a copy of the values for each subscription auto state = std::shared_ptr<merge_state_type>(new merge_state_type(initial, std::move(coordinator), std::move(scbr))); composite_subscription outercs; // when the out observer is unsubscribed all the // inner subscriptions are unsubscribed as well state->out.add(outercs); auto source = on_exception( [&](){return state->coordinator.in(state->source);}, state->out); if (source.empty()) { return; } ++state->pendingCompletions; // this subscribe does not share the observer subscription // so that when it is unsubscribed the observer can be called // until the inner subscriptions have finished auto sink = make_subscriber<source_value_type>( state->out, outercs, // on_next [state](source_value_type st) { composite_subscription innercs; // when the out observer is unsubscribed all the // inner subscriptions are unsubscribed as well auto innercstoken = state->out.add(innercs); innercs.add(make_subscription([state, innercstoken](){ state->out.remove(innercstoken); })); auto selectedSource = on_exception( [&](){return state->coordinator.in(st);}, state->out); if (selectedSource.empty()) { return; } ++state->pendingCompletions; // this subscribe does not share the source subscription // so that when it is unsubscribed the source will continue auto sinkInner = make_subscriber<value_type>( state->out, innercs, // on_next [state, st](value_type ct) { state->out.on_next(std::move(ct)); }, // on_error [state](std::exception_ptr e) { state->out.on_error(e); }, //on_completed [state](){ if (--state->pendingCompletions == 0) { state->out.on_completed(); } } ); auto selectedSinkInner = on_exception( [&](){return state->coordinator.out(sinkInner);}, state->out); if (selectedSinkInner.empty()) { return; } selectedSource->subscribe(std::move(selectedSinkInner.get())); }, // on_error [state](std::exception_ptr e) { state->out.on_error(e); }, // on_completed [state]() { if (--state->pendingCompletions == 0) { state->out.on_completed(); } } ); auto selectedSink = on_exception( [&](){return state->coordinator.out(sink);}, state->out); if (selectedSink.empty()) { return; } source->subscribe(std::move(selectedSink.get())); }
INode& getNode() { return node_status_sub_.getNode(); }
int start() { return subscriber.start(collector.bind()); }
int main(int argc, char* argv[]) { Subscriber app; return app.main(argc, argv, "config.sub"); }
AgpsState* AgpsReleasingState::onRsrcEvent(AgpsRsrcStatus event, void* data) { AgpsState* nextState = this;; switch (event) { case RSRC_SUBSCRIBE: { // already requested for NIF resource, // do nothing until we get RSRC_GRANTED indication // but we need to add subscriber to the list mStateMachine->addSubscriber((Subscriber*)data); // no state change. } break; case RSRC_UNSUBSCRIBE: { Subscriber* subscriber = (Subscriber*) data; if (subscriber->waitForCloseComplete()) { subscriber->setInactive(); } else { // auto notify this subscriber of the unsubscribe Notification notification(subscriber, event, true); mStateMachine->notifySubscribers(notification); } // now check if there is any subscribers left if (!mStateMachine->hasSubscribers()) { // no more subscribers, move to RELEASED state nextState = mReleasedState; } } break; case RSRC_DENIED: // A race condition subscriber unsubscribes before AFW denies resource. case RSRC_RELEASED: { nextState = mAcquiredState; Notification notification(Notification::BROADCAST_INACTIVE, event, true); // notify all subscribers that are active NIF resource RELEASE // by setting false, we keep subscribers on the linked list mStateMachine->notifySubscribers(notification); if (mStateMachine->hasSubscribers()) { nextState = mPendingState; // request from connecivity service for NIF mStateMachine->sendRsrcRequest(GPS_REQUEST_AGPS_DATA_CONN); } else { nextState = mReleasedState; } } break; case RSRC_GRANTED: default: LOC_LOGE("%s: unrecognized event %d", whoami(), event); // no state change. } LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", whoami(), nextState->whoami(), event); return nextState; }
AgpsState* AgpsAcquiredState::onRsrcEvent(AgpsRsrcStatus event, void* data) { AgpsState* nextState = this; switch (event) { case RSRC_SUBSCRIBE: { // we already have the NIF resource, simply notify subscriber Subscriber* subscriber = (Subscriber*) data; // we have rsrc in hand, so grant it right away Notification notification(subscriber, RSRC_GRANTED, false); subscriber->notifyRsrcStatus(notification); // add subscriber to the list mStateMachine->addSubscriber(subscriber); // no state change. } break; case RSRC_UNSUBSCRIBE: { Subscriber* subscriber = (Subscriber*) data; if (subscriber->waitForCloseComplete()) { subscriber->setInactive(); } else { // auto notify this subscriber of the unsubscribe Notification notification(subscriber, event, true); mStateMachine->notifySubscribers(notification); } // now check if there is any subscribers left if (!mStateMachine->hasSubscribers()) { // no more subscribers, move to RELEASED state nextState = mReleasedState; // tell connecivity service we can release NIF mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN); } else if (!mStateMachine->hasActiveSubscribers()) { // only inactive subscribers, move to RELEASING state nextState = mReleasingState; // tell connecivity service we can release NIF mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN); } } break; case RSRC_GRANTED: LOC_LOGW("%s: %d, RSRC_GRANTED already received", whoami(), event); // no state change. break; case RSRC_RELEASED: { LOC_LOGW("%s: %d, a force rsrc release", whoami(), event); nextState = mReleasedState; Notification notification(Notification::BROADCAST_ALL, event, true); // by setting true, we remove subscribers from the linked list mStateMachine->notifySubscribers(notification); } break; case RSRC_DENIED: // no state change. // we are expecting RELEASED. Handling DENIED // may like break our state machine in race conditions. break; default: LOC_LOGE("%s: unrecognized event %d", whoami(), event); // no state change. } LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", whoami(), nextState->whoami(), event); return nextState; }