Synnefo

if SNF_TEST_USE_POSTGRES:

    DATABASES['default'] = {

        'ENGINE': 'django.db.backends.postgresql_psycopg2',

        'USER': 'postgres',

        'PORT': '5432',

    }

elif SNF_TEST_PITHOS_SQLITE_MODULE:

    PITHOS_BACKEND_DB_CONNECTION = DATABASES['default']['NAME']

if SNF_TEST_PITHOS_UPDATE_MD5:

from django.test import TestCase

from django.utils.http import urlencode

import django.utils.simplejson as json

class PithosAPITest(TestCase):

    def setUp(self):

        # Override default block size to spead up tests

        pithos_settings.BACKEND_BLOCK_SIZE = TEST_BLOCK_SIZE

        pithos_settings.BACKEND_HASH_ALGORITHM = TEST_HASH_ALGORITHM

        uuid = map['x-object-uuid']

        assert(uuid == self.uuid)

def test_concurrently(times=2):

    """

    Add this decorator to small pieces of code that you want to test

                    on versions(uuid) """)

        execute(""" create table if not exists attributes

                            primary key (serial, domain, key)

                            foreign key (serial)

                            references versions(serial)

                            on delete cascade ) """)

        execute(""" create index if not exists idx_attributes_domain

                    on attributes(domain) """)

        wrapper = self.wrapper

        wrapper.execute()

        props = (parent, path)

        return self.execute(q, props).lastrowid

        """Lookup the current node of the given path.

           Return None if the path is not found.

            return 0

        return r[0]

        """Delete all versions with the specified

           parent and cluster, and return

           the hashes, the size and the serials of versions deleted.

            return (), 0, ()

        mtime = time()

        self.statistics_update(parent, -nr, -size, mtime, cluster)

        q = ("select hash, serial from versions "

             "where node in (select node "

        for r in self.fetchall():

            hashes += [r[0]]

            serials += [r[1]]

        q = ("delete from versions "

             "where node in (select node "

             "from nodes "

        execute(q, (parent,))

        return hashes, size, serials

        """Delete all versions with the specified

           node and cluster, and return

           the hashes, the size and the serials of versions deleted.

        if not nr:

            return (), 0, ()

        mtime = time()

        q = ("select hash, serial from versions "

             "where node = ? "

        execute(q, (node,))

        return hashes, size, serials

        """Remove the node specified.

           Return false if the node has children or is not found.

        """

        self.execute(q, (node,))

        for population, size, cluster in self.fetchall():

            self.statistics_update_ancestors(

        q = "delete from nodes where node = ?"

        self.execute(q, (node,))

        size += presize

        self.execute(qu, (node, population, size, mtime, cluster))

        """Update the statistics of the given node's parent.

           Then recursively update all parents up to the root.

           Population is not recursive.

        """

        while True:

                break

            props = self.node_get_properties(node)

            if props is None:

            self.statistics_update(parent, population, size, mtime, cluster)

            node = parent

            population = 0  # Population isn't recursive

    def statistics_latest(self, node, before=inf, except_cluster=0):

        """Return population, total size and last mtime

        props = (serial, node)

        self.execute(q, props)

        """Create a new version from the given properties.

           Return the (serial, mtime) of the new version.

        """

        props = (node, hash, size, type, source, mtime, muser,

                 uuid, checksum, cluster)

        serial = self.execute(q, props).lastrowid

        self.nodes_set_latest_version(node, serial)

        q = "update versions set %s = ? where serial = ?" % key

        self.execute(q, (value, serial))

        """Move the version into another cluster."""

        props = self.version_get_properties(serial)

            return

        mtime = time()

        q = "update versions set cluster = ? where serial = ?"

        self.execute(q, (cluster, serial))

        """Remove the serial specified."""

        props = self.version_get_properties(serial)

        cluster = props[CLUSTER]

        mtime = time()

        q = "delete from versions where serial = ?"

        self.execute(q, (serial,))

            execute(q, (serial, domain))

        return self.fetchall()

        """Set the attributes of the version specified by serial.

           Receive attributes as an iterable of (key, value) pairs.

        """

    def attribute_del(self, serial, domain, keys=()):

        """Delete attributes of the version specified by serial.

    def attribute_copy(self, source, dest):

        q = ("insert or replace into attributes "

             "where serial = ?")

        self.execute(q, (dest, source))

    def _construct_filters(self, domain, filterq):

        if not domain or not filterq:

            return None, None

             "v.size, v.type, v.source, v.mtime, v.muser, "

             "v.uuid, v.checksum, v.cluster, a.key, a.value "

             "from nodes n, versions v, attributes a "

             "a.domain = ? and "

             "n.path in (%s)") % ','.join('?' for _ in paths)

        args = [domain]

        map(args.append, paths)

                public_url_security, public_url_alphabet

            )

            q = "insert into public(path, active, url) values(?, 1, ?)"

                logger.info('Public url set for path: %s' % path)

    def public_unset(self, path):