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;
}