Synnefo

        self.db = db

    def load(self, fp):

        self.size = 0

        for block in file_read_iterator(fp, self.blocksize):

            self.append(self._hash_block(block))

            self.size += len(block)

from django.conf import settings

        options = getattr(settings, 'BACKEND', None)[1]

        self.backend = ModularBackend(*options)

def upload(client, file, container, prefix, name=None, mimetype=None):

    hashes.load(open(file))

    kwargs = {'mimetype':mimetype} if mimetype else {}

    v = None

        v = client.create_object_by_hashmap(container, object, map, **kwargs)

        return v

    return client.create_object_by_hashmap(container, object, map, **kwargs)

    def __init__(self, pithosdb, db):

        Migration.__init__(self,  pithosdb)

        engine = create_engine(db)

        metadata = MetaData(engine)

        self.files = Table('files', metadata, *columns)

        metadata.create_all(engine)

    pithosdb = ''

    dt = DataMigration(pithosdb, db)

from pithos.backends.lib.sqlalchemy import Node

from pithos.backends.modular import CLUSTER_NORMAL, CLUSTER_HISTORY, CLUSTER_DELETED

from pithos.backends.lib.sqlalchemy.node import Node

from pithos.backends.lib.sqlalchemy.dbwrapper import DBWrapper

from lib.hashmap import HashMap, file_read_iterator

import mimetypes

class ObjectMigration(Migration):

    def __init__(self, old_db):

        Migration.__init__(self, old_db)

        self.wrapper = ClientWrapper(self.backend)

        params = {'wrapper': DBWrapper(self.backend.db)}

        self.node = Node(**params)

    def create_object(self, username, container, object, filepath, mimetype):

        obj = ''

        path = '/'.join(object.split('/')[:-1])

        name =  object.split('/')[-1]

        #create directory markers

        for f in path.split('/'):

            obj = '%s/%s' %(obj, f) if obj else f

            try:

                self.wrapper.create_directory_marker('pithos', obj, username)

            except NameError, e:

                pass

        self.wrapper.set_account(username)

        prefix = '%s/' %path if path else ''

        print '#', filepath, container, prefix, name, mimetype

        return upload(self.wrapper, filepath, container, prefix, name, mimetype)

    def create_history(self, user, header_id, node_id, deleted=False):

        filebody = Table('filebody', self.metadata, autoload=True)

        gss_user = Table('gss_user', self.metadata, autoload=True)

        j = filebody.join(gss_user, filebody.c.modifiedby_id == gss_user.c.id)

        s = select([filebody.c.filesize, gss_user.c.username], from_obj=j)

        s = s.where(filebody.c.header_id == header_id)

        s = s.order_by(filebody.c.version)

        rp = self.conn.execute(s)

        versions = rp.fetchall()

        print '#', len(versions)

        rp.close()

        i = 0

        for size, modyfied_by  in versions:

            cluster = CLUSTER_HISTORY if i < len(versions) - 1 else CLUSTER_NORMAL

            cluster = cluster if not deleted else CLUSTER_DELETED

            args = (node_id, size, None, modyfied_by, cluster)

            self.node.version_create(*args)

            i += 1

        j = filebody.join(fileheader, filebody.c.id == fileheader.c.currentbody_id)

        s = select([gss_user.c.username,  fileheader.c.id, fileheader.c.folder_id,

                    fileheader.c.name,  fileheader.c.deleted, filebody.c.storedfilepath,

                    filebody.c.mimetype], from_obj=j)

        for username, headerid, folderid, filename, deleted, filepath, mimetype in objects:

            container = 'pithos' if not deleted else 'trash'

            object = '%s/%s' %(path, filename)

            #filepath = '/Users/butters/Downloads/torvalds-linux-0f86267'

            vserial = self.create_object(username, container, object, filepath, mimetype)

            nodeid = self.node.version_get_properties(vserial, keys=('node',))[0]

            self.create_history(username, headerid, nodeid, deleted)

            self.node.version_remove(vserial)

            #self.set_metadata()

            #self.set_public()

            #self.statistics()

            #self.set_permissions()

    def handle_deleted(self):

        pass

    def upload_dir(self, dir, prefix, user, container):

        for f in os.listdir(dir):

            fullpath = '%s/%s' %(dir, f)

            if os.path.isfile(fullpath):

                type = mimetypes.guess_type(fullpath)[0]

                name = '/'.join(fullpath.split(prefix)[1:])

                print '@', user, container, name, fullpath, type

                self.create_object(user, container, name, fullpath, type)

            else: self.upload_dir(fullpath, prefix, user, container)

    def __init__(self, backend):

        self.backend = backend

    def create_object_by_hashmap(self, container, object, map, mimetype=None):

        for h in map['hashes']:

            hashmap.append(h)

        if mimetype:

            meta['content-type'] = mimetype

            return self.backend.update_object_hashmap(*args)

    def update_container_data(self, container, f):

        #just put the blocks

        for block in file_read_iterator(f, self.block_size):

            self.backend.put_block(block)

    old_db = ''

    ot = ObjectMigration(old_db)

    #ot.create_default_containers()

    #ot.create_objects()

    p = ''

    ot.upload_dir(p, p, 'chstath', 'linux')