示例#1
0
void PortCoreOutputUnit::runSimulation() {

    if (op!=NULL) {
        Route route = op->getRoute();
        setMode();
        getOwner().reportUnit(this,true);

        String msg = String("Sending output from ") +
            route.getFromName() + " to " + route.getToName() + " using " +
            route.getCarrierName();
        if (Name(route.getToName()).isRooted()) {
            if (Name(route.getFromName()).isRooted()) {
                YARP_INFO(Logger::get(),msg);
            }
        }

        // Report the new connection
        PortInfo info;
        info.message = msg.c_str();
        info.tag = yarp::os::PortInfo::PORTINFO_CONNECTION;
        info.incoming = false;
        info.created = true;
        info.sourceName = route.getFromName().c_str();
        info.targetName = route.getToName().c_str();
        info.portName = info.sourceName;
        info.carrierName = route.getCarrierName().c_str();
        getOwner().report(info);
    }

    // no thread component
    running = false;

    return;
}
示例#2
0
文件: Protocol.cpp 项目: ale-git/yarp
std::string Protocol::getSenderSpecifier() const
{
    Route r = getRoute();
    // We pull the sender name from the route.
    std::string from = r.getFromName();
    // But we need to add any qualifiers looking in the carrier
    // name.  Ideally, we wouldn't need to bundle that in with
    // the sender name, but we do it for now in the name of
    // backwards compatibility.
    std::string carrier = r.getCarrierName();
    size_t start = carrier.find('+');
    if (start != std::string::npos) {
        from += " (";
        for (size_t i = start + 1; i < (size_t)carrier.length(); i++) {
            char ch = carrier[i];
            if (ch == '+') {
                from += ") (";
            } else if (ch == '.') {
                from += " ";
            } else {
                from += ch;
            }
        }
        from += ")";
    }
    return from;
}
示例#3
0
bool Protocol::open(const Route& route) {
    setRoute(route);
    setCarrier(route.getCarrierName());
    if (delegate==NULL) return false;
    // We are the initiator of the connection, so we
    // send a header (carrier-dependent).
    bool ok = sendHeader();
    if (!ok) return false;
    // Expect a resonse to the header (carrier-dependent).
    return expectReplyToHeader();
}
示例#4
0
文件: Protocol.cpp 项目: ale-git/yarp
void Protocol::setRoute(const Route& route)
{
    Route r = route;

    // We reorganize the route to reduce variation in naming.
    // If there are qualifiers in the source port name, propagate
    // those qualifiers to the carrier.
    std::string from = r.getFromName();
    std::string carrier = r.getCarrierName();
    if (from.find(' ') != std::string::npos) {
        Bottle b(from);
        if (b.size() > 1) {
            r.setFromName(b.get(0).toString());
            for (size_t i = 1; i < b.size(); i++) {
                Value& v = b.get(i);
                Bottle* lst = v.asList();
                if (lst != nullptr) {
                    carrier.append("+").append(lst->get(0).toString()).append(".").append(lst->get(1).toString());
                } else {
                    carrier.append("+").append(v.toString());
                }
            }
            r.setCarrierName(carrier);
        }
    }

    // Record canonicalized route.
    this->route = r;

    // Check if we have a receiver modifier.
    if (!recv_delegate) {
        Bottle b(getSenderSpecifier());
        if (b.check("recv")) {
            need_recv_delegate = true;
        }
    }

    // Check if we have a sender modifier.
    if (!send_delegate) {
        Bottle b(getSenderSpecifier());
        if (b.check("send")) {
            need_send_delegate = true;
        }
    }
}
示例#5
0
void PortCoreInputUnit::run() {
    running = true;
    phase.post();

    Route route;
    bool wasNoticed = false;
    bool posted = false;

    bool done = false;
    
    YARP_ASSERT(ip!=NULL);
    
    PortCommand cmd;
    
    if (autoHandshake) {
        bool ok = true;
        if (!reversed) {
            ip->open(getName().c_str());
        }
        if (!ok) {
            YARP_DEBUG(Logger::get(),String("new input connection to ")+
                       getOwner().getName()+ " is broken");
            done = true;
        } else {
            route = ip->getRoute();

            // just before going official, tag any lurking inputs from
            // the same source as undesired
            if (Name(route.getFromName()).isRooted()) {
                YARP_SPRINTF3(Logger::get(),
                              debug,
                              "Port %s starting up, flushing routes %s->*->%s",
                              getOwner().getName().c_str(),
                              route.getFromName().c_str(),
                              route.getToName().c_str());
                getOwner().removeIO(Route(route.getFromName(),
                                          route.getToName(),"*"),true);
            }
            officialRoute = route;
            setMode();
            getOwner().reportUnit(this,true);

            String msg = String("Receiving input from ") + 
                route.getFromName() + " to " + route.getToName() + 
                " using " +
                route.getCarrierName();
            if (Name(route.getFromName()).isRooted()) {
                if (reversed||ip->getConnection().isPush()) {
                    YARP_INFO(Logger::get(),msg);
                    posted = true;
                } else {
                    YARP_DEBUG(Logger::get(),msg);
                }
            } else {
                YARP_DEBUG(Logger::get(),msg);
            }
            
            // Report the new connection
            PortInfo info;
            info.message = msg.c_str();
            info.tag = yarp::os::PortInfo::PORTINFO_CONNECTION;
            info.incoming = true;
            info.created = true;
            info.sourceName = route.getFromName().c_str();
            info.targetName = route.getToName().c_str();
            info.portName = info.targetName;
            info.carrierName = route.getCarrierName().c_str();
            
            if (info.sourceName!="admin"&&info.sourceName!="null") {
                getOwner().report(info);
                wasNoticed = true;
            }
        }
        
    } else {
        bool ok = ip->open(""); // anonymous connection
        route = ip->getRoute();
        if (!ok) {
            done = true;
        }
    }

    if (!reversed) {
        if (!ip->getConnection().isPush()) {
            /* IP=OP */
            OutputProtocol *op = &(ip->getOutput());
            Route r = op->getRoute();
            // reverse route
            op->rename(Route().addFromName(r.getToName()).addToName(r.getFromName()).addCarrierName(r.getCarrierName()));
                    
            getOwner().addOutput(op);
            ip = NULL;
            done = true;
        }
    }
    
    if (closing) {
        done = true;
    }
    
    void *id = (void *)this;
    
    while (!done) {
        ConnectionReader& br = ip->beginRead();
            
        if (br.getReference()!=NULL) {
            //printf("HAVE A REFERENCE\n");
            if (localReader!=NULL) {
                bool ok = localReader->read(br);
                if (!br.isActive()) { done = true; break; }
                if (!ok) continue;
            } else {
                PortManager& man = getOwner();
                bool ok = man.readBlock(br,id,NULL);
                if (!br.isActive()) { done = true; break; }
                if (!ok) continue;
            }
            //printf("DONE WITH A REFERENCE\n");
            if (ip!=NULL) {
                ip->endRead();
            }
            continue;
        }
            
        if (autoHandshake&&(ip->getConnection().canEscape())) {
            bool ok = cmd.read(br);
            if (!br.isActive()) { done = true; break; }
            if (!ok) continue;
        } else {
            cmd = PortCommand('d',"");
            if (!ip->checkStreams()) { done = true; break; }
        }
        
        if (closing||isDoomed()) {
            done = true;
            break;
        }
        char key = cmd.getKey();
        //ACE_OS::printf("Port command is [%c:%d/%s]\n",
        //	     (key>=32)?key:'?', key, cmd.getText().c_str());
        
        PortManager& man = getOwner();
        OutputStream *os = NULL;
        if (br.isTextMode()) {
            os = &(ip->getOutputStream());
        }
        
        switch (key) {
        case '/':
            YARP_SPRINTF3(Logger::get(),
                          debug,
                          "Port command (%s): %s should add connection: %s",
                          route.toString().c_str(),
                          getOwner().getName().c_str(), 
                          cmd.getText().c_str());
            man.addOutput(cmd.getText(),id,os);
            break;
        case '!':
            YARP_SPRINTF3(Logger::get(),
                          debug,
                          "Port command (%s): %s should remove output: %s",
                          route.toString().c_str(),
                          getOwner().getName().c_str(), 
                          cmd.getText().c_str());
            man.removeOutput(cmd.getText().substr(1,String::npos),id,os);
            break;
        case '~':
            YARP_SPRINTF3(Logger::get(),
                          debug,
                          "Port command (%s): %s should remove input: %s",
                          route.toString().c_str(),
                          getOwner().getName().c_str(), 
                          cmd.getText().c_str());
            man.removeInput(cmd.getText().substr(1,String::npos),id,os);
            break;
        case '*':
            man.describe(id,os);
            break;
        case 'D':
        case 'd':
            {
                bool suppressed = false;
                    
                // this will be the new way to signal that
                // replies are not expected.
                if (key=='D') {
                    ip->suppressReply();
                }
                    
                String env = cmd.getText();
                if (env.length()>1) {
                    if (!suppressed) {
                        // This is the backwards-compatible
                        // method for signalling replies are
                        // not expected.  To be used until
                        // YARP 2.1.2 is a "long time ago".
                        if (env[1]=='o') {
                            ip->suppressReply();
                        }
                    }
                    if (env.length()>2) {
                        //YARP_ERROR(Logger::get(),
                        //"***** received an envelope! [%s]", env.c_str());
                        String env2 = env.substr(2,env.length());
                        man.setEnvelope(env2);
                        ip->setEnvelope(env2);
                    }
                }
                if (localReader) {
                    localReader->read(br);
                    if (!br.isActive()) { done = true; break; }
                } else {
                    if (ip->getReceiver().acceptIncomingData(br)) {
                        man.readBlock(ip->getReceiver().modifyIncomingData(br),id,os);
                    } else {
                        skipIncomingData(br);
                    }
                    if (!br.isActive()) { done = true; break; }
                }
            }
            break;
        case 'a':
            {
                man.adminBlock(br,id,os);
            }
            break;
        case 'r':
            /*
              In YARP implementation, OP=IP.
              (This information is used rarely, and when used
              is tagged with OP=IP keyword)
              If it were not true, memory alloc would need to
              reorganized here
            */
            {
                OutputProtocol *op = &(ip->getOutput());
                ip->endRead();
                Route r = op->getRoute();
                // reverse route
                op->rename(Route().addFromName(r.getToName()).addToName(r.getFromName()).addCarrierName(r.getCarrierName()));
                    
                getOwner().addOutput(op);
                ip = NULL;
                done = true;
            }
            break;
        case 'q':
            done = true;
            break;
        case 'i':
            printf("Interrupt requested\n");
            //ACE_OS::kill(0,2); // SIGINT
            //ACE_OS::kill(Logger::get().getPid(),2); // SIGINT
            ACE_OS::kill(Logger::get().getPid(),15); // SIGTERM
            break;
        case '?':
        case 'h':
            if (os!=NULL) {
                BufferedConnectionWriter bw(true);
                bw.appendLine("This is a YARP port.  Here are the commands it responds to:");
                bw.appendLine("*       Gives a description of this port");
                bw.appendLine("d       Signals the beginning of input for the port's owner");
                bw.appendLine("do      The same as \"d\" except replies should be suppressed (\"data-only\")");
                bw.appendLine("q       Disconnects");
                bw.appendLine("i       Interrupt parent process (unix only)");
                bw.appendLine("r       Reverse connection type to be a reader");
                bw.appendLine("/port   Requests to send output to /port");
                bw.appendLine("!/port  Requests to stop sending output to /port");
                bw.appendLine("~/port  Requests to stop receiving input from /port");
                bw.appendLine("a       Signals the beginning of an administrative message");
                bw.appendLine("?       Gives this help");
                bw.write(*os);
            }
            break;
        default:
            if (os!=NULL) {
                BufferedConnectionWriter bw(true);
                bw.appendLine("Port command not understood.");
                bw.appendLine("Type d to send data to the port's owner.");
                bw.appendLine("Type ? for help.");
                bw.write(*os);
            }
            break;
        }
        if (ip!=NULL) {
            ip->endRead();
        }
        if (ip==NULL) {
            done = true;
            break;
        }
        if (closing||isDoomed()||(!ip->checkStreams())) {
            done = true;
            break;
        }
    }

    setDoomed(true);
  
    YARP_DEBUG(Logger::get(),"PortCoreInputUnit closing ip");
    access.wait();
    if (ip!=NULL) {
        ip->close();
    }
    access.post();
    YARP_DEBUG(Logger::get(),"PortCoreInputUnit closed ip");

    if (autoHandshake) {
        String msg = String("Removing input from ") + 
            route.getFromName() + " to " + route.getToName();

        if (Name(route.getFromName()).isRooted()) {
            if (posted) {
                YARP_INFO(Logger::get(),msg);
            }
		} else {
	        YARP_DEBUG(Logger::get(),"PortCoreInputUnit (unrooted) shutting down");
		}

        getOwner().reportUnit(this,false);

        if (wasNoticed) {
            // Report the disappearing connection
            PortInfo info;
            info.message = msg.c_str();
            info.tag = yarp::os::PortInfo::PORTINFO_CONNECTION;
            info.incoming = true;
            info.created = false;
            info.sourceName = route.getFromName().c_str();
            info.targetName = route.getToName().c_str();
            info.portName = info.targetName;
            info.carrierName = route.getCarrierName().c_str();

            if (info.sourceName!="admin") {
                getOwner().report(info);
            }
        }

    } else {
        YARP_DEBUG(Logger::get(),"PortCoreInputUnit shutting down");
    }

    if (localReader!=NULL) {
        delete localReader;
        localReader = NULL;
    }

    running = false;
    finished = true;

    // it would be nice to get my entry removed from the port immediately,
    // but it would be a bit dodgy to delete this object and join this
    // thread within and from themselves
}
示例#6
0
void PortCoreOutputUnit::closeBasic() {
    bool waitForOther = false;
    if (op!=NULL) {
        op->getConnection().prepareDisconnect();
        Route route = op->getRoute();
        if (op->getConnection().isConnectionless()||
            op->getConnection().isBroadcast()) {
            YARP_SPRINTF1(Logger::get(),
                         debug,
                         "output for route %s asking other side to close by out-of-band means",
                         route.toString().c_str());
            Companion::disconnectInput(route.getToName().c_str(),
                                       route.getFromName().c_str(),true);
        } else {
            if (op->getConnection().canEscape()) {
                BufferedConnectionWriter buf(op->getConnection().isTextMode());
                PortCommand pc('\0',String("q"));
                pc.write(buf);
                //printf("Asked for %s to close...\n",
                //     op->getRoute().toString().c_str());
                waitForOther = op->write(buf);
            }
        }

        String msg = String("Removing output from ") +
            route.getFromName() + " to " + route.getToName();

        if (Name(route.getToName()).isRooted()) {
            if (Name(route.getFromName()).isRooted()) {
                YARP_INFO(Logger::get(), msg);
            }
        }

        getOwner().reportUnit(this,false);

        // Report the disappearing connection
        PortInfo info;
        info.message = msg.c_str();
        info.tag = yarp::os::PortInfo::PORTINFO_CONNECTION;
        info.incoming = false;
        info.created = false;
        info.sourceName = route.getFromName().c_str();
        info.targetName = route.getToName().c_str();
        info.portName = info.sourceName;
        info.carrierName = route.getCarrierName().c_str();
        getOwner().report(info);
    }


    if (op!=NULL) {
        if (waitForOther) {
            // quit is only acknowledged in certain conditions
            if (op->getConnection().isTextMode()&&
                op->getConnection().supportReply()) {
                InputStream& is = op->getInputStream();
                ManagedBytes dummy(1);
                is.read(dummy.bytes());
            }
        }
        op->close();
        delete op;
        op = NULL;
    }
}