vos/corelibs/vos/remotesite.cc

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    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

    Peter Amstutz <tetron@interreality.org>
*/

#include "remotesite.hh"
#include "message.hh"

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <cstdarg>
#include <deque>
#include <string>
#include <map>

using namespace VOS;

multimap<string, metaobject_extender_t> RemoteSite::remoteObjectExtensionTable;

RemoteSite::RemoteSite()
    : VobjectImplementation("", 0, false), RemoteMetaObject("", 0),
      RemoteVobject("", 0), MetaObject(0), localpeer(0), disconnected(false)
{
    setGreeted(false);
}

RemoteSite::~RemoteSite()
{
    LOG("remotesite", 4, "deleting " << getURL().getString());
    if(localpeer) localpeer->release(); // acquired by: doSitePeering()
}

LocalSite& RemoteSite::getLocalPeer() throw (NoLocalPeerError)
{
    if(! localpeer) throw NoLocalPeerError("Remote site has no local peer (it has probably disconnected).");
    localpeer->acquire();
    return *localpeer;
}

void RemoteSite::flushIncomingBuffers()
{
    localpeer->flushIncomingBuffers();
}

void RemoteSite::addNotification(NotifyEvent* ev)
{
    localpeer->addNotification(ev);
}

void RemoteSite::flushNotifications()
{
    localpeer->flushNotifications();
}

void RemoteSite::lockNotificationFlush()
{
    localpeer->lockNotificationFlush();
}

void RemoteSite::unlockNotificationFlush()
{
    localpeer->unlockNotificationFlush();
}

void RemoteSite::sendUpdateMessage(Message* m)
{
    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& pos = m->getField(i);
                    if(pos.key != "pos") break;
                    const Message::Field& name = m->getField(++i);
                    if(name.key != "name") break;
                    const Message::Field& path = m->getField(++i);
                    if(path.key != "path") break;
                    deque<string> objtypes;
                    if((i+1) < m->getNumFields()) {
                        const Message::Field* type = &(m->getField(i+1));
                        while(type->key == "type") {
                            objtypes.push_back(type->value);
                            i++;
                            if(i+1 < m->getNumFields()) {
                                type = &(m->getField(i+1));
                            } else break;
                        }
                    }
                    bool newobject=false;
                    int position=atoi(pos.value.c_str());
                    try {
                        vRef<ParentChildRelation> c = VobjectImplementation::findChild(name.value);
                        URL u(path.value);
                        vRef<Site> st = c->child->getSite();
                        if(!(c->position == position
                             && st->hasHostAlias(u.getHostAndPort())
                             && c->child->getURL().getPath() == u.getPath()))
                        {
                            newobject = true;
                        }
                    } catch(NoSuchObjectError) {
                        newobject = true;
                    }
                    if(newobject) {
                        vRef<RemoteMetaObject> rmo = new RemoteMetaObject(name.value, this);
                        // setChild() cannot be done in the constructor or it will crash the constructor
                        setChild(position, name.value, &rmo);
                        if(objtypes.size()) {
                            for(deque<string>::iterator j = objtypes.begin(); j != objtypes.end(); j++) {
                                if((*j).size() > 0) rmo->types.insert(*j);
                            }
                            for(deque<string>::iterator j = objtypes.begin(); j != objtypes.end(); j++) {
                                if((*j).size() > 0) rmo->handleNewType(*j);
                            }
                        } else rmo->getTypes();
                    }
                }
            } catch(Message::NoSuchFieldError) { }
        }
    } catch(NoSuchObjectError) {
    } catch(NoSuchSiteError) {
    } catch(URL::BadURLError) {
    }

    LOG("refcount", 5, "before sending to RemoteMetaObject::sendUpdateMessage count on message " << m->getCount());
    RemoteMetaObject::sendUpdateMessage(m);
    LOG("refcount", 5, "after sending to RemoteMetaObject::sendUpdateMessage count on message " << m->getCount());
}

/* leapfrogs the RemoteVobject setChild, because
   there is no way you can connect an object to a remote site directly
*/
void RemoteSite::setChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, TimeoutError)
{
    if(! child) RemoteVobject::setChild(position, contextual_name, child);
    else {
        rREF(Site&, s, child->getSite(),
             if(&s == this) {
                 VobjectImplementation::setChild(this, position, contextual_name, child);
             } else throw AccessControlError("Cannot change the child of a remote site like this");
            );
    }
}

void RemoteSite::setURL(const URL& u)
{
    url = u;
}

void RemoteSite::excise()
{
    for(int i = (int)children.size() - 1; i >= 0; i--) {
        ParentChildRelation* c = children[i];
        if(c) {
            c->acquire();
            Vobject* ch = c->child;
            if(ch) {
                ch->acquire();
                ch->excise();
                ch->release();
            }
            c->release();
        }
    }

    RemoteMetaObject::excise();

    LOG("refcount", 5, "remotesite: done trying to excise, count on this remote site is " << getCount());

    disconnected=true;

    if(localpeer && !localpeer->checkScheduleHoldsSite(this)) {
        Site::removeSite(*this);
    }

    if(localpeer) {
        localpeer->removeRemotePeer(this);
        localpeer = 0;
    }

//  site = 0;
//  VobjectImplementation::site = 0;
}

void RemoteSite::lockChildNotifyOutgoing(Vobject* v)
{
    childlockSet.insert(v);
}

void RemoteSite::unlockChildNotifyOutgoing(Vobject* v, const string& nonce)
{
    set<Vobject*>::iterator n = childlockSet.find(v);
    if(n != childlockSet.end()) {
        childlockSet.erase(n);

        vRef<Message> m = new Message();
        m->setType("update");
        m->setFrom(v->getURL().getString());
        m->setTo(getURL().getString());
        m->setMethod("core:set-child-update");
        m->setNonce(nonce);

        const ChildList& c = v->getChildren();
        for(ChildList::const_iterator i = c.begin(); i != c.end(); i++) {
            m->insertField(-1, "pos", (*i)->position);
            m->insertField(-1, "name", (*i)->contextual_name);
            m->insertField(-1, "path", (*i)->child->getURL().getString());
            /*if(meta_cast<Site*>(&(*fromobject))) {
                const TypeSet& ts = getTypes();
                if(ts.size()) {
                    for(TypeSet::const_iterator ti = ts.begin(); ti != ts.end(); ti++) {
                        m->insertField(-1, "type", *ti);
                    }
                } else {
                    m->insertField(-1, "type", "");
                }
                }*/
        }
        sendMessage(&m);
    }
}


void RemoteSite::lockParentNotifyOutgoing(Vobject* v)
{
    parentlockSet.insert(v);
}

void RemoteSite::unlockParentNotifyOutgoing(Vobject* v, const string& nonce)
{
    set<Vobject*>::iterator n = parentlockSet.find(v);
    if(n != parentlockSet.end()) {
        parentlockSet.erase(n);

        vRef<Message> m = new Message();
        m->setType("update");
        m->setFrom(v->getURL().getString());
        m->setTo(getURL().getString());
        m->setMethod("core:insert-parent-update");
        m->setNonce(nonce);

        const ParentSet& c = v->getParents();
        for(ParentSet::const_iterator i = c.begin(); i != c.end(); i++) {
            m->insertField(-1, "pos", (*i)->position);
            m->insertField(-1, "name", (*i)->contextual_name);
            m->insertField(-1, "path", (*i)->parent->getURL().getString());
        }
        sendMessage(&m);
    }
}

void RemoteSite::lockTypeNotifyOutgoing(Vobject* v)
{
    typelockSet.insert(v);
}

void RemoteSite::unlockTypeNotifyOutgoing(Vobject* v, const string& nonce)
{
    set<Vobject*>::iterator n = typelockSet.find(v);
    if(n != typelockSet.end()) {
        typelockSet.erase(n);

        vRef<Message> m = new Message();
        m->setType("update");
        m->setFrom(v->getURL().getString());
        m->setTo(getURL().getString());
        m->setMethod("core:type-add-update");
        m->setNonce(nonce);

        const TypeSet& c = v->getTypes();
        for(TypeSet::const_iterator i = c.begin(); i != c.end(); i++) {
            m->insertField(-1, "type", *i);
        }
        sendMessage(&m);
    }
}


void RemoteSite::notifyChildInserted(VobjectEvent& e)
{
    if(childlockSet.count(e.getParent())) return;

    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getParent()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:insert-child-update");

    LOG("notifyChildInserted", 5, "*** here we are! ***");

    char x[16];
    snprintf(x, sizeof(x), "%i", e.getPosition());
    m->insertField(-1, "pos", string(x));
    m->insertField(-1, "name", e.getContextualName());
    m->insertField(-1, "path", e.getChild()->getURL().getString());
    if(meta_cast<Site*>(e.getParent())) {
        const TypeSet& ts = getTypes();
        if(ts.size()) {
            for(TypeSet::const_iterator ti = ts.begin(); ti != ts.end(); ti++) {
                m->insertField(-1, "type", *ti);
            }
        } else {
            m->insertField(-1, "type", "");
        }
    }
    sendMessage(&m);
}

void RemoteSite::notifyChildReplaced(VobjectEvent& e)
{
    if(childlockSet.count(e.getParent())) return;

    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getParent()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:set-child-update");

    char x[16];
    snprintf(x, sizeof(x), "%i", e.getPosition());
    m->insertField(-1, "pos", string(x));
    m->insertField(-1, "name", e.getContextualName());
    m->insertField(-1, "path", e.getChild()->getURL().getString());

    sendMessage(&m);
}

void RemoteSite::notifyChildRemoved(VobjectEvent& e)
{
    if(childlockSet.count(e.getParent())) return;

    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getParent()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:remove-child-update");

    char x[16];
    snprintf(x, sizeof(x), "%i", e.getPosition());
    m->insertField(-1, "pos", x);
    m->insertField(-1, "name", e.getContextualName());
    m->insertField(-1, "path", e.getChild()->getURL().getString());

    sendMessage(&m);
}

void RemoteSite::notifyParentInserted(VobjectEvent& e)
{
    if(parentlockSet.count(e.getChild())) return;

    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getChild()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:insert-parent-update");

    char x[16];
    snprintf(x, sizeof(x), "%i", e.getPosition());
    m->insertField(-1, "pos", string(x));
    m->insertField(-1, "name", e.getContextualName());
    m->insertField(-1, "path", e.getParent()->getURL().getString());

    sendMessage(&m);
}

void RemoteSite::notifyParentRemoved(VobjectEvent& e)
{
    if(parentlockSet.count(e.getChild())) return;

    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getChild()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:remove-parent-update");

    char x[16];
    snprintf(x, sizeof(x), "%i", e.getPosition());
    m->insertField(-1, "pos", string(x));
    m->insertField(-1, "name", e.getContextualName());
    m->insertField(-1, "path", e.getParent()->getURL().getString());

    sendMessage(&m);
}

void RemoteSite::notifyTypeInserted(VobjectEvent& e)
{
    if(typelockSet.count(e.getAffectedObject())) return;

    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getAffectedObject()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:type-add-update");

    m->insertField(-1, "type", e.getNewType());

    sendMessage(&m);
}

void RemoteSite::notifyTypeRemoved(VobjectEvent& e)
{
    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(e.getAffectedObject()->getURL().getString());
    m->setTo(getURL().getString());
    m->setMethod("core:remove-type-update");

    m->insertField(-1, "type", e.getNewType());

    sendMessage(&m);
}

void RemoteSite::release()
{
    /*if(disconnected
       && getHostAliases().size() > 0
       && (getCount()-1) == getHostAliases().size()) {
        LOG("remotesite", 3, "site is disconnected and not held by anything but site table.  releasing from site table...");
        disconnected=false;
        Site::removeSite(*this);
        }*/
    RemoteVobject::release();
}

void RemoteSite::extendMetaObject(RemoteMetaObject* root, const char* p)
{
    pair<MI, MI> g = remoteObjectExtensionTable.equal_range(p);
    for(MI it = g.first; it != g.second; it++) {
        MetaObject* newext = (*it).second(root, p);
    }
}

#if 0
void RemoteSite::extendMetaObject(RemoteMetaObject* root, ...)
{
    va_list ap;
    va_start(ap, root);
    extendMetaObjectV(root, ap);
    va_end(ap);
}
#endif


MetaObject* RemoteSite::createMetaObject(const char* desiredname, const deque<string>& typelist)
{
    //string name = uniqueName(desiredname);  will be done by the local site anyway
    string name = desiredname;
    MetaObject* ret = 0;
    vRef<Message> m = new Message();
    vRef<LocalSite> ls = initFields(this, &m, "core:create-object", true);
    m->insertField(-1, "name", name);
    for(deque<string>::const_iterator i = typelist.begin(); i != typelist.end(); i++) {
        m->insertField(-1, "type", *i);
    }
    sendMessage(&m);
    try {
        vRef<Message> r = ls->waitFor(m->getNonce(), this);
        try {
            const Message::Field f = r->getField("error");
            throw AccessControlError(f.value);
        } catch(Message::NoSuchFieldError) {
            try {
                const Message::Field f = r->getField("path");
                ret = meta_cast<MetaObject*>(&findObjectFromRoot(f.value));
            } catch(Message::NoSuchFieldError) {
                throw AccessControlError("reply did not contain path field");
            } catch(NoSuchSiteError) {
                throw RemoteError("reply path field illegal");
            } catch(NoSuchObjectError x) {
                throw RemoteError(string("could not access newly created object: ") + x.what());
            } catch(URL::BadURLError) {
                throw RemoteError("reply path field illegal");
            } catch(AccessControlError x) {
                throw x;
            } catch(RemoteError x) {
                throw x;
            }
        }
    } catch(exception& e) {
        LOG("remotesite", 2, "RemoteVobject::removeChild: caught exception from waitFor: " << e.what());
    }
    return ret;
}

MetaObject* RemoteSite::createMetaObject(const char* name, const char* first, ...)
{
    MetaObject* ret;
    va_list ap;
    va_start(ap, first);
    deque<string> args;
    if(first) {
        args.push_back(first);
        for(;;) {
            char* p=va_arg(ap, char*);
            if(p == 0) break;
            args.push_back(p);
        }
    }
    try {
        ret = createMetaObject(name, args);
    } catch(...) {
        va_end(ap);
        throw;
    }
    va_end(ap);
    return ret;
}


#if 0
MetaObject* RemoteSite::createMetaObject(const deque<string>& typelist)
{
    return createMetaObject(generateUniqueName(), typelist);
}

MetaObject* RemoteSite::createMetaObject()
{
    return createMetaObjectT(0);
}
MetaObject* RemoteSite::createMetaObjectT(const char* first, ...)
{
    MetaObject* ret;
    va_list ap;
    va_start(ap, first);
    deque<string> args;
    if(first) args.push_back(first);
    if(first) {
        for(;;) {
            char* p=va_arg(ap, char*);
            if(p == 0) break;
            args.push_back(p);
        }
    }
    try {
        ret = createMetaObject(args);
    } catch(...) {
        va_end(ap);
        throw;
    }
    va_end(ap);
    return ret;
}

MetaObject* RemoteSite::createMetaObjectV(va_list ap)
{
    deque<string> args;
    for(;;) {
        char* p=va_arg(ap, char*);
        if(p == 0) break;
        args.push_back(p);
    }
    return createMetaObject(args);
}


MetaObject* RemoteSite::createMetaObjectV(const string& name, va_list ap)
{
    deque<string> args;
    for(;;) {
        char* p=va_arg(ap, char*);
        if(p == 0) break;
        args.push_back(p);
    }
    return createMetaObject(name, args);
}
#endif

void RemoteSite::addRemoteObjectExtension(const char* type, metaobject_extender_t newmethod)
{
    remoteObjectExtensionTable.insert(multimap<string, metaobject_extender_t>::value_type(string(type), newmethod));
}

void RemoteSite::removeRemoteObjectExtension(const char* type, metaobject_extender_t oldmethod)
{
    pair<MI, MI> g = remoteObjectExtensionTable.equal_range(type);
    for(MI it = g.first; it != g.second; it++) {
        if((*it).second == oldmethod) {
            remoteObjectExtensionTable.erase(it);
            break;
        }
    }
}


void RemoteSite::printExtensionTable(ostream& stream) {
    for(MI i = remoteObjectExtensionTable.begin(); i != remoteObjectExtensionTable.end(); i++) {
        stream << i->first << endl;
    }
}

void RemoteSite::catchIncomingMessage(const string& nonce)
{
    waitingFor[nonce] = pair<bool, Message*>(false, 0);
}

void RemoteSite::clearCaughtMessage(const string& nonce)
{
    if(waitingFor.count(nonce)) {
        if(waitingFor[nonce].second)
            waitingFor[nonce].second->release(); // acquired by: RemoteSocketSite::flushIncomingBuffers
        waitingFor.erase(nonce);
    }
}

bool RemoteSite::messageInProgress(const string& nonce)
{
    if(waitingFor.count(nonce)) return waitingFor[nonce].first;
    else return false;
}

bool RemoteSite::messageReady(const string& nonce)
{
    if(waitingFor.count(nonce)) return (waitingFor[nonce].second != 0);
    else return false;
}

Message* RemoteSite::retrieveCaughtMessage(const string& nonce)
{
    if(waitingFor.count(nonce)) {
        Message* m = waitingFor[nonce].second;
        if(m) m->acquire(); // released by: the caller of this method
        return m;
    }
    else return 0;
}

---