Exemplo n.º 1
0
    def get_elements(self,
                     ids=None,
                     query=None,
                     limit=0,
                     skip=0,
                     sort=None,
                     with_count=False,
                     hint=None,
                     projection=None,
                     tags=None,
                     *args,
                     **kwargs):

        _query = {} if query is None else query.copy()

        one_element = isinstance(ids, basestring)

        if ids is not None:
            if one_element:
                _query[MongoStorage.ID] = ids

            else:
                _query[MongoStorage.ID] = {'$in': ids}

        if tags:
            _query[MongoStorage.TAGS] = tags

        cursor = self._find(_query, projection)

        # set limit, skip and sort properties
        if limit:
            cursor.limit(limit)

        if skip:
            cursor.skip(skip)

        if sort is not None:
            sort = Storage._resolve_sort(sort)
            if sort:
                cursor.sort(sort)

        if hint is None:
            hint = self._get_hint(query=_query, cursor=cursor)

        if hint is not None:
            cursor.hint(hint)

        result = MongoCursor(cursor)

        if one_element:
            result = result[0] if result else None

        # if with_count, add count to the result
        if with_count:
            # calculate count
            count = cursor.count()
            result = result, count

        return result
Exemplo n.º 2
0
    def get_elements(
        self,
        ids=None,
        query=None,
        limit=0,
        skip=0,
        sort=None,
        with_count=False,
        hint=None,
        projection=None,
        *args,
        **kwargs
    ):

        _query = {} if query is None else query.copy()

        one_element = isinstance(ids, basestring)

        if ids is not None:
            if one_element:
                _query[MongoStorage.ID] = ids

            else:
                _query[MongoStorage.ID] = {"$in": ids}

        cursor = self._find(_query, projection)

        # set limit, skip and sort properties
        if limit:
            cursor.limit(limit)

        if skip:
            cursor.skip(skip)

        if sort is not None:
            sort = Storage._resolve_sort(sort)
            if sort:
                cursor.sort(sort)

        if hint is None:
            hint = self._get_hint(query=_query, cursor=cursor)

        if hint is not None:
            cursor.hint(hint)

        result = MongoCursor(cursor)

        if one_element:
            result = result[0] if result else None

        # if with_count, add count to the result
        if with_count:
            # calculate count
            count = cursor.count()
            result = result, count

        return result
Exemplo n.º 3
0
    def _resolve_sort(sort):
        """Resolve input sort in transforming it to a list of tuple of (name,
        direction).

        :param sort: sort configuration. Can be a string, or
        :type sort: list of {tuple(str, int), str}
        :return: depending on type of sort:
            - str: [(sort, Storage.ASC)]
            - dict: [(sort['property'], sort.get('direction', Storage.ASC))]
            - tuple: [(sort[0], sort[1])]
            - list:
                - str
        :rtype: str, dict, tuple or list
        """

        result = []
        if isinstance(sort, basestring):

            result.append((sort, Storage.ASC))

        elif isinstance(sort, dict):

            sort_tuple = None
            field = sort.get('property', None)

            if field is not None:
                direction = sort.get('direction', Storage.ASC)
                if isinstance(direction, basestring):
                    direction = getattr(Storage, direction.upper())
                    # Need field property filled in the sort document
                    sort_tuple = (field, direction)

            if sort_tuple is not None:
                result.append(sort_tuple)

        elif isinstance(sort, tuple):

            direction = sort[1]
            if isinstance(direction, basestring):
                direction = getattr(Storage, direction.upper())
            result.append((sort[0], direction))

        elif isinstance(sort, Iterable):

            for item in sort:
                result += Storage._resolve_sort(item)

        return result
Exemplo n.º 4
0
    def _resolve_sort(sort):
        """Resolve input sort in transforming it to a list of tuple of (name,
        direction).

        :param sort: sort configuration. Can be a string, or
        :type sort: list of {tuple(str, int), str}
        :return: depending on type of sort:
            - str: [(sort, Storage.ASC)]
            - dict: [(sort['property'], sort.get('direction', Storage.ASC))]
            - tuple: [(sort[0], sort[1])]
            - list:
                - str
        :rtype: str, dict, tuple or list
        """

        result = []
        if isinstance(sort, basestring):

            result.append((sort, Storage.ASC))

        elif isinstance(sort, dict):

            sort_tuple = None
            field = sort.get('property', None)

            if field is not None:
                direction = sort.get('direction', Storage.ASC)
                if isinstance(direction, basestring):
                    direction = getattr(Storage, direction.upper())
                    # Need field property filled in the sort document
                    sort_tuple = (field, direction)

            if sort_tuple is not None:
                result.append(sort_tuple)

        elif isinstance(sort, tuple):

            direction = sort[1]
            if isinstance(direction, basestring):
                direction = getattr(Storage, direction.upper())
            result.append((sort[0], direction))

        elif isinstance(sort, Iterable):

            for item in sort:
                result += Storage._resolve_sort(item)

        return result
Exemplo n.º 5
0
    def copy(self, target):
        """Copy self content into target storage.

        target type must implement the same class in cstorage packege as self.
        If self implements directly cstorage.Storage, we don't care about
        target type

        :param target: target storage where copy content
        :type target: same as self or any storage if type(self) is Storage
        """

        result = 0

        from canopsis.storage.core import Storage
        from canopsis.storage.periodic import PeriodicStorage
        from canopsis.storage.timed import TimedStorage
        from canopsis.storage.timedtyped import TimedTypedStorage
        from canopsis.storage.typed import TypedStorage

        storage_types = [
            Storage, PeriodicStorage, TimedStorage, TimedTypedStorage,
            TypedStorage
        ]

        if isinstance(self, storage_types):
            for _ in storage_types:
                if isinstance(self, storage_types):
                    if not isinstance(target, storage_types):
                        raise Storage.StorageError(
                            'Impossible to copy {0} content into {1}. \
Storage types must be of the same type.'.format(self, target))
                    else:
                        self._copy(target)

            result = -1

        return result
Exemplo n.º 6
0
    def setUp(self):
        """initialize storages"""

        self.storages = []

        testconf = self._testconfcls()

        if testconf.storages:

            for storage in testconf.storages:

                storagecls = lookup(storage)

                storage = storagecls(
                    data_scope=data_scope, conf_paths=testconf.conf_paths,
                    **testconf.params
                )

                self.storages.append(storage)

        else:

            for protocol in testconf.protocols:

                for data_type in testconf.data_types:

                    for data_scope in testconf.data_scopes:

                        storage = Storage.get_middleware(
                            protocol=protocol, data_type=data_type,
                            data_scope=data_scope,
                            conf_paths=testconf.conf_paths,
                            **testconf.params
                        )

                        self.storages.append(storage)