vos/metaobjects/misc/search.cc

Go to the documentation of this file.

/* $Id: search.cc,v 1.25 2003/08/06 08:04:13 tetron Exp $ */


/* This file was generated by otd2cpp.pl
    Copyright (C) 2002 Peter Amstutz <tetron@interreality.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

*/

/** @file search.cc Code: a MetaObject for Search object types. */

#include <vos/corelibs/vos/vos.hh>

#include <vos/metaobjects/property/property.hh>
#include "search.hh"

#include <fstream>

/* Constructor */
Search::Search(MetaObject* s) : MetaObject(s)
{
    accessControl = &NoPropertyAccessControl::static_;
}

/* Destructor */
Search::~Search() {
}

/* Get/Set default AC */
void Search::setPropertyAccessControl(PropertyAccessControl* ac) {
    accessControl = ac;
}
PropertyAccessControl* Search::getPropertyAccessControl() {
    return accessControl;
}

LocalSearch::LocalSearch(MetaObject* s) : Search(s), MetaObject(s)
{
    addMessageHandler<LocalSearch>("misc:search", this, &LocalSearch::handleSearch);
}

LocalSearch::~LocalSearch() {
    //acccessControl = &NoPropertyAccessControl::static_;
}

/* Initialize required subobjects: */

void LocalSearch::initialize(PropertyAccessControl* ac) {
    accessControl = ac;
    initialize();
}

void LocalSearch::initialize() {
}

RemoteSearch::RemoteSearch(MetaObject* s) : Search(s), MetaObject(s)
{
    addUpdateHandler<RemoteSearch>("misc:search-done", this, &RemoteSearch::handleSearchDone);
}

RemoteSearch::~RemoteSearch() {
}

/* Return type string ("search:search") */

const string Search::getType() {
    return string("misc:search");
}

/* Register extenders with libvos MetaFactory */
void Search::registerExtenders() {
    static bool done = false;
    if(! done) {
    LocalSite::addLocalObjectExtension(typeid(LocalSearch).name(), &LocalSearch::new_LocalSearch);
    LocalSite::addLocalObjectExtension(typeid(Search).name(), &LocalSearch::new_LocalSearch);
    LocalSite::addLocalObjectExtension("misc:search", &LocalSearch::new_LocalSearch);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteSearch).name(), &RemoteSearch::new_RemoteSearch);
    RemoteSite::addRemoteObjectExtension(typeid(Search).name(), &RemoteSearch::new_RemoteSearch);
    RemoteSite::addRemoteObjectExtension("misc:search", &RemoteSearch::new_RemoteSearch);
    done = true;
    }
}


/* Process remote update messages */
void RemoteSearch::sendUpdateMessage(Message* m) {

    /* let superclass have message... */
    Search::sendUpdateMessage(m);

    bool mark = false;
    for(set<string>::iterator i = searches.begin(); i != searches.end(); i++) {
        if(m->getNonce() == (string("acquire-") + (*i))) {
            mark = true;
            break;
        }
    }

    if(mark) {
        try {
            if(m->getMethod() == "core:insert-child-update"
               || m->getMethod() == "core:set-child-update") {
                try {
                    for(int i=0; i < m->getNumFields(); ++i) {
                        const Message::Field& name = m->getField(i);
                        if(name.key != "name") continue;
                        try {
                            vRef<Vobject> v = findObject(name.value);
                            v->addFlag("from-search");
                        } catch(NoSuchObjectError) { }
                    }
                } catch(Message::NoSuchFieldError) { }
            }
        } catch(NoSuchObjectError) {
        } catch(NoSuchSiteError) {
        } catch(URL::BadURLError) {
        }
    }
}

/* Local Actuators: */

/* Do search. */

deque<LocalSearch::PatternRule*> LocalSearch::makeRules(Message* rules)
{
    deque<PatternRule*> prules;

    int rc = 0, i = 0;
    for(; i < rules->getNumFields() && rules->getField(i).key != "typerule"; i++);
    for(; i < rules->getNumFields(); i+=3) {
        rc++;

        const Message::Field& typerule = rules->getField(i);
        const Message::Field& childrule = rules->getField(i+1);
        const Message::Field& action = rules->getField(i+2);

        if(typerule.key != "typerule") {
            LOG("search", 2, "missing type rule parmeter");
            return prules;
        }
        if(childrule.key != "childrule") {
            LOG("search", 2, "missing child rule parmeter");
            return prules;
        }
        if(action.key != "action") {
            LOG("search", 2, "missing action parmeter");
            return prules;
        }

        PatternRule* currule = new PatternRule;

    currule->typePatternEmpty = (typerule.value.size() == 0);   
        LOG("search", 4, "type pattern: " << typerule.value);
        regcomp(&currule->typepattern, typerule.value.c_str(), REG_EXTENDED | REG_NOSUB);

        if(! (childrule.value.size() == 0
              || childrule.value[0] == '/'
              || (childrule.value[0] == '!' && childrule.value[1] == '/')))
        {
            LOG("search", 2, "child rule doesn't start with '/' and isn't blank");
            return prules;
        }

        unsigned int n = 1, c = 1;
        if(childrule.value.size() > 0) {
            if(childrule.value[0] == '!') {
                currule->negateChild = true;
                n++;
                c++;
            } else currule->negateChild = false;

            vector<regex_t> childpatsplit;
            for(; n < childrule.value.size(); n++) {
                if(childrule.value[n] == '/') {
                    LOG("search", 4, "child pattern: " << childrule.value.substr(c, n-c));

                    regex_t aregexp;
                    regcomp(&aregexp, childrule.value.substr(c, n-c).c_str(), REG_EXTENDED | REG_NOSUB);

                    currule->childpattern.push_back(aregexp);
                    c = n+1;
                }
            }
        }
        if(n == childrule.value.size()) {
            LOG("search", 4, "child pattern: " << childrule.value.substr(c, n-c));

            regex_t aregexp;
            regcomp(&aregexp, childrule.value.substr(c, n-c).c_str(), REG_EXTENDED | REG_NOSUB);

            currule->childpattern.push_back(aregexp);
        }

        for(unsigned int n = 0, c = 0; n < action.value.size(); n++) {
            while(n < action.value.size() && isspace(action.value[n])) { n++; c++; }
            while(n < action.value.size() && action.value[n] != ',') n++;
            LOG("search", 4, "action: '" << action.value.substr(c, n-c) << "'");
            currule->actions.push_back(action.value.substr(c, n-c));
            c = n+1;
        }
        prules.push_back(currule);
    }
    return prules;
}


bool LocalSearch::doActions(Vobject* currentobject,
                            const deque<PatternRule*>& rules,
                            const PatternRule& thisrule,
                            RemoteCOD* cod,
                            list<Vobject*>& touchedObjects)
{
    if(currentobject->isRemote()) return false;
    if(cod->getVobject(currentobject->getName())) return true;

    LOG("searched", 4, "doActions looking at " << currentobject->getURL().getString());

    vRef<LocalSite> ls = cod->getLocalSite();
    vRef<RemoteSite> rs = cod->getRemoteSite();

    char nonce[32];
    snprintf(nonce, sizeof(nonce), "%i", (int)rand());
    CatchUpdatesFilter cu(nonce);
    bool wantIt = false;
    bool dorecurse = false;
    bool ret = true;

    for(vector<string>::const_iterator act = thisrule.actions.begin();
        act != thisrule.actions.end(); act++)
    {
        if((*act) == "recurse") {
            dorecurse = true;
        } else if((*act) == "acquire") {
            wantIt = true;
        } else if((*act) == "stop") {
            ret = false;
            break;
        } else {
            try {
                vRef<MessageBlock> mb = rs->getMessageBlock(*act);
                /*vRef<MessageContext> mc = new MessageContext();

                mc->setParameter("to", currentobject->getURL().getString());
                mc->setParameter("from", rs->getURL().getString());
                mc->setParameter("nonce", nonce);*/

                rs->insertMessageFilter(-1, &cu);

                for(int i = 0; i < mb->numMessages(); i++) {
                    try {
                        vRef<Message> msg = new Message(*mb->getMessage(i));
                        //msg->setMessageContext(&mc);
                        msg->setSourceSite(&rs);

                        //if(msg->getTo() == "")
                        msg->setTo(currentobject->getURL().getString());
                        //if(msg->getFrom() == "")
                        msg->setFrom(rs->getURL().getString());
                        msg->setNonce(nonce);

                        LOG("search", 4, "to " << currentobject->getURL().getString()
                            << " sending " << msg->getFormattedString());

                        currentobject->sendMessage(&msg);
                    } catch(runtime_error e) {
                        LOG("remotesite", 2, "Error applying rule: " << e.what());
                    } catch(...) {
                    }
                }

                rs->removeMessageFilter(&cu);
            } catch(Site::NoSuchMessageBlockError) {
                LOG("search", 2, "No such message block defined \"" << *act << "\"");
            }
        }
    }

    if(wantIt) {
        LOG("search", 4, "Adding " << currentobject->getURL().getString() << " to the COD");
        cod->addVobject(currentobject, currentobject->getTypes(), cu.mb, cu.savechildren);
    } else {
        rs->sendMessage(cu.mb);
    }

    if(dorecurse) search(currentobject, rules, cod, touchedObjects);

    return ret;
}

bool LocalSearch::actOnChildren(Vobject* currentobject,
                                const deque<PatternRule*>& rules,
                                const PatternRule& thisrule,
                                int patternpart,
                                RemoteCOD* cod,
                                list<Vobject*>& touchedObjects)
{
    bool ret = true;
    const Vobject::ChildList& cl = currentobject->getChildren();

    LOG("searched", 4, "actOnChildren looking at " << currentobject->getURL().getString());

    for(Vobject::ChildList::const_iterator i = cl.begin(); i != cl.end(); i++) {
        if((*i)->child->isLocal()) {
            LOG("search", 4, "looking at " << (*i)->contextual_name);
            int e = regexec(&thisrule.childpattern[patternpart], (*i)->contextual_name.c_str(), 0, 0, 0);
            if(thisrule.negateChild) e = ((e == 0) ? REG_NOMATCH : 0);
            calledregex++;
            if(e == 0) {
                LOG("search", 4, "matched");
                if(thisrule.childpattern.size()-1 == (unsigned int)patternpart) {
                    ret &= doActions((*i)->child, rules, thisrule, cod, touchedObjects);
                } else actOnChildren((*i)->child, rules, thisrule, patternpart+1, cod, touchedObjects);
            } else {
                if(e != REG_NOMATCH) {
                    char errbuf[256];
                    regerror(e, &thisrule.childpattern[patternpart], errbuf,  sizeof(errbuf));
                    LOG("search", 2, "oops bad regex " << errbuf);
                    return false;
                }
            }
        }
    }
    return ret;
}

void LocalSearch::search(Vobject* currentobject,
                         const deque<PatternRule*>& rules,
                         RemoteCOD* cod,
                         list<Vobject*>& touchedObjects)
{
    if(currentobject->isRemote()) return;

    if(!currentobject->checkFlag("searched")) {
        LOG("searched", 4, "search looking at " << currentobject->getURL().getString());

        currentobject->addFlag("searched");
        currentobject->acquire(); // released by: handleSearch
        touchedObjects.push_back(currentobject);

        for(deque<PatternRule*>::const_iterator currule = rules.begin(); currule != rules.end(); currule++) {
            bool doRule = false;
            const Vobject::TypeSet& ts = currentobject->getTypes();
            if((*currule)->typePatternEmpty && ts.size() == 0) doRule = true;
            for(Vobject::TypeSet::const_iterator tsi = ts.begin(); tsi != ts.end(); tsi++) {
                int e = regexec(&(*currule)->typepattern, (*tsi).c_str(), 0, 0, 0);
                calledregex++;
                if(e == 0) {
                    LOG("search", 4, "matched " << (*tsi));
                    doRule = true;
                    break;
                } else {
                    if(e != REG_NOMATCH) {
                        char errbuf[256];
                        regerror(e, &(*currule)->typepattern, errbuf,  sizeof(errbuf));
                        LOG("search", 2, "oops bad regex " << errbuf);
                        return;
                    }
                }
            }
            if(doRule) {
                if((*currule)->childpattern.size() > 0) {
                    if(! actOnChildren(currentobject, rules, (**currule), 0, cod, touchedObjects)) return;
                } else {
                    if(! doActions(currentobject, rules, (**currule), cod, touchedObjects)) return;
                }
            }
        }
    }
}


/* Message Handlers:  */

void LocalSearch::handleSearch(Message* m) {
    deque<PatternRule*> rules = makeRules(m);

    for(deque<PatternRule*>::iterator i = rules.begin(); i != rules.end(); i++) {
        for(vector<string>::iterator n = (*i)->actions.begin();  n != (*i)->actions.end(); n++)
        {
            LOG("search", 4, "ok: " << *n);
        }
        LOG("search", 4, "---");
    }


    vRef<LocalSite> mysite = dynamic_cast<LocalSite&>(getSite());

    vRef<Message> reply;
    try {
        reply = new Message();
        LocalVobject::initReply(this, &reply, m, "misc:search-done");
    } catch(Message::NoSuchFieldError e) {
            /* A field wasn't found */
    }

    double selectwait = mysite->getTimeoutOnSelect();
    mysite->setTimeoutOnSelect(0);

    vRef<RemoteSite> sourcesite = dynamic_cast<RemoteSite*>(m->getSourceSite());

#ifdef USE_STRSTREAM
    strstream of;
#else
    stringstream of;
#endif
    RemoteCOD rc(of, *mysite, *sourcesite);

    LOG("search", 3, "starting search...");

    double d = getRealTime();
    calledregex = 0;
    for(int i = 0; i < m->getNumFields(); i++){
        const Message::Field& f = m->getField(i);
        if(f.key == "start") {
            try {
                list<Vobject*> touchedObjects;
                vRef<Vobject> v = findObject(f.value);
                search(&v, rules, &rc, touchedObjects);

                for(list<Vobject*>::iterator li = touchedObjects.begin(); li != touchedObjects.end(); li++) {
                    (*li)->removeFlag("searched");
                    (*li)->release();
                }
            } catch(NoSuchObjectError) {
            } catch(runtime_error x) {
                LOG("search", 1, "Got error doing search " << x.what());
                // send error reply
            }
        }
    }
    LOG("search", 3, "search done, took " << getRealTime() - d << " sec with " << calledregex << " regexes");

    d = getRealTime();
    LOG("search", 3, "starting COD  write");

    unsigned char* data;
    unsigned int size;
    rc.writeCOD(&data, &size);

    LOG("search", 3, "did write COD, took " << getRealTime() - d << " sec");

    for(unsigned int i = 0; i < rules.size(); i++) {
        delete rules[i];
    }
    rules.resize(0);

    mysite->flushIncomingBuffers();
    mysite->setTimeoutOnSelect(selectwait);

    try {
        vRef<Vobject> from = Vobject::findObjectFromRoot(m->getFrom());
        reply->insertField(-1, "cod", string((char*)data, size), true);
        from->sendMessage(&reply);
    } catch(...) {
    }
}

/* Remote Actuators: */

/* Do search. */
string RemoteSearch::doSearch(const deque<string>& objects, const deque<string>& rules, SearchListener* listener) {
    string n = doSearch(objects, rules, true);
    RefCounted* r = dynamic_cast<RefCounted*>(listener);
    if(r) r->acquire();
    listeners[n] = listener;
    return n;
}

string RemoteSearch::doSearch(const deque<string>& objects, const deque<string>& rules, bool async, RemoteCOD** cod) {
    /* Create a new message and send it to the local object, and wait for reply. */

    vRef<Message> m = new Message();
    vRef<LocalSite> ls = RemoteVobject::initFields(this, &m, "misc:search", true);

    for(deque<string>::const_iterator i = objects.begin(); i != objects.end(); i++) {
        m->insertField(-1, "start", *i);
    }
    for(deque<string>::const_iterator i = rules.begin(); i != rules.end(); i++) {
        m->insertField(-1, "typerule", *i);
        i++;
        m->insertField(-1, "childrule", *i);
        i++;
        m->insertField(-1, "action", *i);
    }

    searches.insert(m->getNonce());

    sendMessage(&m);
    vRef<RemoteSite> site = dynamic_cast<RemoteSite&>(getSite());
    if(! async) {
        vRef<Message> reply = ls->waitFor(m->getNonce(), &site, 3600);
            try {
                LOG("search", 4,"starting to unpack COD");
                double d = getRealTime();

                const Message::Field& f = reply->getField("cod");
#if 0
#ifdef USE_STRSTREAM
                strstream input((char*)(f.value.c_str()), f.value.length());
                // cast from (const char*) should be OK, since we are
                // only going to read from this string, not write to it.
#else
                stringstream input(f.value, ios::in | ios::bin);
#endif
#endif
                /* for testing only
                   fstream outtest("out.cod", ios::out | ios::bin);
                   outtest.write(f.value.c_str(), f.value.size());
                   outtest.close();
                */
                vRef<RemoteSite> rs = dynamic_cast<RemoteSite*>(reply->getSourceSite());
                vRef<LocalSite> ls = rs->getLocalPeer();

                RemoteCOD* rc = new RemoteCOD(*ls, *rs);
                LOG("search", 4, "x4");
                rc->readCOD((unsigned char*)(f.value.c_str()), f.value.length());
                LOG("search", 4, "x5");

                if(cod) {
                    *cod = rc;
                } else delete rc;
                LOG("search", 3, "unpacking done, took " << getRealTime() - d << " sec");
            } catch(Message::NoSuchFieldError) {
                LOG("search", 2, "Received search-done message but could not find the COD field");
            } catch(COD::eof) {
                LOG("search", 2, "COD ended prematurely");
            }
    }
    return m->getNonce();
}


/* Generators for factory */

MetaObject* LocalSearch::new_LocalSearch(MetaObject *s, const string& type) {
    LocalSearch* o = new LocalSearch(s);
    return o;
}

MetaObject* RemoteSearch::new_RemoteSearch(MetaObject *s, const string& type) {
    return new RemoteSearch(s);
}

/* Handle search-done. */

void RemoteSearch::handleSearchDone(Message* m) {
    string n = m->getNonce();
    if(listeners.find(n) != listeners.end()) {
        try {
            const Message::Field& f = m->getField("cod");
#if 0
#ifdef USE_STRSTREAM
            strstream input((char*) f.value.c_str(), f.value.length());
            // cast from (const char*) should be OK, since we are
            // only going to read from this string, not write to it.
#else
            stringstream input(f.value);
#endif
#endif
            vRef<RemoteSite> rs = dynamic_cast<RemoteSite*>(m->getSourceSite());
            vRef<LocalSite> ls = rs->getLocalPeer();

            RemoteCOD cod(*ls, *rs);
            cod.readCOD((unsigned char*)(f.value.c_str()), f.value.length());
        } catch(Message::NoSuchFieldError) {
            LOG("search", 2, "Received search-done message but could not find the COD field");
        }

        listeners[n]->notifySearchDone();
        RefCounted* r = dynamic_cast<RefCounted*>(listeners[n]);
        if(r) r->release();
        listeners.erase(n);
    }
}

---