vos/metaobjects/property/directory.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, 2002 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 <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>

#ifndef S_ISDIR
#define S_ISDIR(x) (x & _S_IFDIR)
#endif

#ifndef S_ISREG
#define S_ISREG(x) (x & _S_IFREG)
#endif

#include <vos/corelibs/vos/vos.hh>
#include "property.hh"
#include "fileproperty.hh"
#include "directory.hh"

struct InsertEntry
{
    bool isDir;
    int pos;
    string filename;
};


Directory::Directory(string name, LocalSite* localsite, VobjectAccessControl* ac, const string& path)
    : VobjectImplementation(name = localsite->uniqueName(name.c_str()), localsite, true), LocalVobject(name, localsite, ac),
      MetaObject(0), LocalMetaObject(name, localsite, ac)
{
    dirpath = path;
    localsite->LocalVobject::insertChild(-1, name, this);
    status.st_mtime = 0;
    insync = false;
}

Directory::~Directory()
{
}

const Vobject::ChildList& Directory::getChildren() throw (AccessControlError, RemoteError)
{
    if(! insync) sync();
    return LocalMetaObject::getChildren();
}

Vobject& Directory::findObject(const string& path)
    throw (Vobject::NoSuchSiteError, Vobject::NoSuchObjectError, URL::BadURLError,
           Vobject::AccessControlError, Vobject::RemoteError)
{
    if(! insync) sync();
    return LocalMetaObject::findObject(path);
}

Vobject::ParentChildRelation& Directory::findChild(const string& path)
    throw (Vobject::NoSuchObjectError, Vobject::AccessControlError, Vobject::RemoteError)
{
    if(! insync) sync();
    return LocalMetaObject::findChild(path);
}

void Directory::syncTypes(string filename, Vobject* obj)
{
    struct stat typestat;
    if(stat(filename.c_str(), &typestat) == 0) {
        if(typestat.st_mtime > status.st_mtime) {
            if(FILE* f = fopen(filename.c_str(), "r")) {
                char t[256];
                while(fscanf(f, " %255s ", t) != EOF) obj->addType(t);
                fclose(f);
            }
        }
    }

}

void Directory::sync()
{
    struct stat curstat;
    stat(dirpath.c_str(), &curstat);

    // check if directory has changed since we last looked at it
    if(curstat.st_mtime > status.st_mtime) {
        insync = true;

        string typepath = dirpath;
        typepath += "/.vostypes";
        syncTypes(typepath, this);

        DIR* dir = opendir(dirpath.c_str()); // scandir(3) might make my life easier, but it's not POSIX...
        if(! dir) {
            LOG("directory", 2, "Cannot read directory \"" << dirpath << "\": " << strerror(errno));
            return;
        }

        map<string, bool> filelist;

        struct dirent* entry;
        while((entry = readdir(dir))) {
            if(strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
                string filepath = dirpath;
                filepath += "/";
                filepath += entry->d_name;

                struct stat fileinfo;
                stat(filepath.c_str(), &fileinfo);
                if(S_ISREG(fileinfo.st_mode)) {
                    filelist[filepath.substr(dirpath.length()+1)] = false;
                } else if(S_ISDIR(fileinfo.st_mode)) {
                    filelist[filepath.substr(dirpath.length()+1)] = true;
                }
            }
        }

        map<string, bool>::iterator fi = filelist.begin();

        fi = filelist.begin();
        const ChildList& children = getChildren();
        ChildList::const_iterator ci = children.begin();
        list<int> needdelete;

        while(fi != filelist.end() || ci != children.end()) {
            if(fi == filelist.end()) {
                // some item exists in VOS but not in the directory, so want to delete it
                needdelete.push_back((*ci)->position);
                ci++;
            } else if((*fi).first[0] == '.') {
                // skip dotfiles entirely
                fi++;
            } else if(ci == children.end()) {
                // some item exists in directory but not in VOS (want to add it, will do this in next pass)
                fi++;
            } else {
                FileProperty* fp = meta_cast<FileProperty*>((*ci)->child);
                string filebackend = (fp ? fp->getFileBackend() : "");
                unsigned int pos = (fp ? filebackend.find_last_of('/') + 1 : 0);
                cout << "del " << filebackend.substr(pos) << "\n";
                if(!fp || filebackend.substr(pos) != (*fi).first) {
                    // directory and VOS don't match, start deleting stuff from VOS until we get back on track
                    needdelete.push_back((*ci)->position);
                    ci++;
                } else {
                    // else VOS/directory match completely -- keep going
                    ci++;
                    fi++;
                }
            }
        }

        for(list<int>::reverse_iterator i = needdelete.rbegin(); i != needdelete.rend(); i++) {
            LOG("directory", 3, "removing child " << *i);
            removeChild(*i); // XXX should excise maybe
        }

        fi = filelist.begin();
        ci = children.begin();
        list<InsertEntry> needinsert;
        InsertEntry e;
        while(fi != filelist.end() || ci != children.end()) {
            if(fi == filelist.end()) {
                // some item exists in VOS but not in the directory -- this shouldn't happen!
                LOG("directory", 2, "VOS and directory don't match after delete sync???");
                ci++;
            } else if((*fi).first[0] == '.') {
                // skip dotfiles entirely
                fi++;
            } else if(ci == children.end()) {
                // some item exists in directory but not in VOS, want to add it
                e.pos = children.size();
                e.filename = (*fi).first;
                e.isDir = (*fi).second;
                needinsert.push_back(e);
                fi++;
            } else {
                FileProperty* fp = meta_cast<FileProperty*>((*ci)->child);
                string filebackend = (fp ? fp->getFileBackend() : "");
                unsigned int pos = (fp ? filebackend.find_last_of('/') + 1 : 0);
                cout << "ins " << filebackend.substr(pos) << "\n";
                if(!fp || filebackend.substr(pos) != (*fi).first) {
                    // directory and VOS don't match -- add vobjects until it we're back on track
                    e.pos = children.size();
                    e.filename = (*fi).first;
                    e.isDir = (*fi).second;
                    needinsert.push_back(e);
                    fi++;
                } else {
                    // else VOS/directory match completely -- keep going
                    ci++;
                    fi++;
                }
            }
        }

        vRef<LocalSite> localsite = dynamic_cast<LocalSite&>(getSite());
        for(list<InsertEntry>::reverse_iterator i = needinsert.rbegin(); i != needinsert.rend(); i++) {
            LOG("directory", 3, "adding child " << (*i).filename);
            if((*i).isDir) {
                vRef<Directory> d2 = new Directory(localsite->generateUniqueName(),
                                                   &localsite, getAccessControls()[0], dirpath+"/"+(*i).filename);
                d2->sync();
                insertChild((*i).pos, (*i).filename, &d2);
            } else {
                vRef<FileProperty> fp = MetaObject::meta_cast<FileProperty*>
                    (localsite->createMetaObject((char*)0, typeid(FileProperty).name(), 0));
                fp->insertPropertyAccessControl(-1, &ReadOnlyPropertyAccessControl::static_);
                fp->setFileBackend(dirpath+"/"+(*i).filename);
                string childname = (*i).filename;
                unsigned int hashpos;
                if((hashpos = childname.find_first_of('#')) != string::npos) childname = childname.substr(0, hashpos);
                insertChild((*i).pos, childname, &fp);
            }
        }

        for(ci = children.begin(); ci != children.end(); ci++) {
            syncTypes(dirpath+"/."+(*ci)->contextual_name+".vostypes", (*ci)->child);
        }

        stat(dirpath.c_str(), &status);
        insync = false;
    }
}

---