Пример #1
0
 def get_cache(self, *args, **kwargs):
     _cache_options['args'] = args
     _cache_options['kwargs'] = kwargs
     try:
         c = cache.get_cache(*args, **kwargs)
         _cache_options['cls'] = c.namespace.__class__.__name__
     except TypeError:
         _cache_options['cls'] = 'NoImplementation'
         c = cache.get_cache(*args, type='memory', **kwargs)
     return c
Пример #2
0
 def get_cache(self, *args, **kwargs):
     _cache_options['args'] = args
     _cache_options['kwargs'] = kwargs
     try:
         c = cache.get_cache(*args, **kwargs)
         _cache_options['cls'] = c.namespace.__class__.__name__
     except TypeError:
         _cache_options['cls'] = 'NoImplementation'
         c = cache.get_cache(*args, type='memory', **kwargs)
     return c
Пример #3
0
 def get_cache(self, *args, **kwargs):
     _cache_options["args"] = args
     _cache_options["kwargs"] = kwargs
     try:
         c = cache.get_cache(*args, **kwargs)
         _cache_options["cls"] = c.namespace.__class__.__name__
     except TypeError:
         _cache_options["cls"] = "NoImplementation"
         c = cache.get_cache(*args, type="memory", **kwargs)
     return c
Пример #4
0
 def simple(self, a):
     c = cache.get_cache("BasicTGController.index")
     x = c.get_value(key=a, 
                     createfunc=lambda: "cached %s" % a,
                     type="memory",
                     expiretime=3600)
     return x
Пример #5
0
 def expiry(self, a):
     mockdb['expiry'] = a # inject a value into the context
     c = cache.get_cache("BasicTGController.index")
     x = c.get_value(key='test', 
                     createfunc=self.createfunc,
                     type="memory",
                     expiretime=100)
     return x
Пример #6
0
    def get_takeoff_locations(self):
        _cache = cache.get_cache('users.takeoff_locations', expire=60 * 5)

        def update_cache():
            return Location.get_clustered_locations(Flight.takeoff_location_wkt,
                                                    filter=(Flight.pilot == self.user))

        return _cache.get(key=self.user.id, createfunc=update_cache)
Пример #7
0
    def get_similarity(self):

        def calc():
            log.debug('Calculating similarity matrix for key %s...', self.key)
            return all_pairs([s.source for s in self.submissions])

        simcache = cache.get_cache('similarity')
        matrix = simcache.get_value(key=self.key, createfunc=calc, expiretime=7 * 24 * 60 * 60)  # 7 days
        return matrix
Пример #8
0
    def get_bestsellers(cls):
        def _fetch_bestsellers():
            skus = []
            for product in cls.get_many('product', {'active': True}).sort([('sold', DESCENDING)]).limit(12).all():
                skus.append(product.configurations[0].sku)
            return skus

        bestselling_cache = cache.get_cache('bestselling_products')
        bestseller = bestselling_cache.get_value(key='bestseller',
                                                 expiretime=24 * 3600,
                                                 createfunc=_fetch_bestsellers)
        return bestseller
Пример #9
0
 def create_shortcut_(self, **kw):
     
     logger = logging.getLogger('PermissionsController.create_shortcut_')
     try:
         user_id = get_paramw(kw, 'user_id', int)
         permission_id = get_paramw(kw, 'permission_id', int)
         groups = get_paramw(kw, 'groups', sj.loads)
         
         p = dbs.query(SapnsPermission).get(permission_id)
         
         if p.type not in [SapnsPermission.TYPE_LIST, SapnsPermission.TYPE_PROCESS] or \
         p.type == SapnsPermission.TYPE_PROCESS and p.requires_id:
             raise EPermissions(_(u'Shortcuts can only be created from LIST and PROCESS (no required id) type permissions'))
         
         title = p.display_name
         if p.type == SapnsPermission.TYPE_LIST:
             title = p.class_.title
         
         for id_group in groups:
             
             group = dbs.query(SapnsShortcut).get(id_group)
             
             sc = SapnsShortcut()
             sc.user_id = user_id
             sc.parent_id = id_group
             sc.permission_id = permission_id
             sc.title = title
             sc.order = group.next_order()
             dbs.add(sc)
             dbs.flush()
             
             _key = '%d_%d' % (user_id, id_group)
             cache.get_cache('user_get_shortcuts').remove_value(key=_key)
         
         return dict(status=True)
     
     except EPermissions, e:
         logger.error(e)
         return dict(status=False, msg=unicode(e))
Пример #10
0
    def stats(self, **kw):
        log.info('stats %s' % kw)
        wpublic = kw.pop('wpublic', 0)
        anonymous = identity.anonymous()

        def usage_resource():
            log.info("CALL EXPENSIVE")
            all_count = data_service.count("image",
                                           wpublic=wpublic,
                                           images2d=True,
                                           parent=False)
            image_count = data_service.count("image",
                                             wpublic=wpublic,
                                             permcheck=not anonymous)
            #images2d = data_service.count("image", wpublic=wpublic, images2d=True)
            tag_count = data_service.count("tag",
                                           wpublic=wpublic,
                                           permcheck=not anonymous,
                                           parent=False)
            gob_count = data_service.count("gobject",
                                           wpublic=wpublic,
                                           permcheck=not anonymous,
                                           parent=False)

            resource = etree.Element('resource', uri='/usage/stats')
            etree.SubElement(resource,
                             'tag',
                             name='number_images',
                             value=str(all_count))
            etree.SubElement(resource,
                             'tag',
                             name='number_images_user',
                             value=str(image_count))
            #etree.SubElement(resource, 'tag', name='number_images_planes', value=str(images2d))
            etree.SubElement(resource,
                             'tag',
                             name='number_tags',
                             value=str(tag_count))
            etree.SubElement(resource,
                             'tag',
                             name='number_gobs',
                             value=str(gob_count))

            return etree.tostring(resource)

        usage_cache = cache.get_cache("usage")
        resource = usage_cache.get_value(key=identity.get_username(),
                                         createfunc=usage_resource,
                                         expiretime=3600)
        return resource
Пример #11
0
 def all_the_vats(cls):
     def aggregate_vats():
         vat_for_status = DBSession.impl.db.orders.aggregate([{'$project': {'items': 1, 'status': 1}},
                                                              {'$unwind': '$items'},
                                                              {'$group': {'_id': '$status',
                                                                          'vat_rates': {'$addToSet': '$items.rate'}}}])
         return sorted(set(chain(*[v['vat_rates'] for v in vat_for_status])))
     vat_cache = cache.get_cache('all_the_vats')
     cachedvalue = vat_cache.get_value(
         key='42',
         createfunc=aggregate_vats,
         expiretime=3600*24*30  # one month
     )
     return cachedvalue
Пример #12
0
    def uploads(self, **kw):
        log.info('uploads %s' % kw)

        def fetch_counts():
            return self.get_counts('image', 31)

        usage_cache = cache.get_cache("uploads")
        counts, days = usage_cache.get_value(key=identity.get_username(),
                                             createfunc=fetch_counts,
                                             expiretime=600)

        resource = etree.Element('resource', uri='/usage/uploads')
        etree.SubElement(resource,
                         'tag',
                         name='counts',
                         value=','.join(counts))
        etree.SubElement(resource, 'tag', name='days', value=','.join(days))
        return etree.tostring(resource)
Пример #13
0
    def analysis_monthly(self, **kw):
        log.info('uploads %s' % kw)

        def fetch_counts():
            return self.get_counts_month('mex', 13)

        usage_cache = cache.get_cache("analysis_monthly")
        counts, days = usage_cache.get_value(key=identity.get_username(),
                                             createfunc=fetch_counts,
                                             expiretime=3600)
        #counts, days = self.get_counts_month('mex', 13)
        resource = etree.Element('resource', uri='/usage/analysis_monthly')
        etree.SubElement(resource,
                         'tag',
                         name='counts',
                         value=','.join(counts))
        etree.SubElement(resource, 'tag', name='days', value=','.join(days))
        return etree.tostring(resource)
Пример #14
0
    def index(self, **kw):
        query = self.get_latest_fixes()

        na_cache = cache.get_cache('tracking.nearest_airport', expire=60 * 60)

        tracks = []
        for track in query.all():
            def get_nearest_airport():
                airport = Airport.by_location(track.location, None)
                if airport is None:
                    return None, None

                distance = airport.distance(track.location)
                return airport, distance

            airport, distance = na_cache.get(key=track.id, createfunc=get_nearest_airport)
            tracks.append([track, airport, distance])

        return dict(tracks=tracks)
Пример #15
0
    def index(self, **kw):
        na_cache = cache.get_cache('tracking.nearest_airport', expire=60 * 60)

        def add_nearest_airport_data(track):
            def get_nearest_airport():
                airport = Airport.by_location(track.location, None)
                if airport is None:
                    return None, None

                distance = airport.distance(track.location)
                return airport, distance

            airport, distance = na_cache.get(key=track.id, createfunc=get_nearest_airport)
            return track, airport, distance

        tracks = []
        tracks.extend(map(add_nearest_airport_data, TrackingFix.get_latest()))

        return dict(tracks=tracks)
Пример #16
0
    def get_distance_flights(self):
        _cache = cache.get_cache('users.distance_flights', expire=60 * 5)

        def update_cache():
            distance_flights = []

            largest_flight = self.user.get_largest_flights().first()
            if largest_flight:
                distance_flights.append([largest_flight.olc_classic_distance,
                                         largest_flight])

            for distance in [50000, 100000, 300000, 500000, 700000, 1000000]:
                distance_flight = self.get_distance_flight(distance)
                if distance_flight is not None:
                    distance_flights.append([distance, distance_flight])

            distance_flights.sort()
            return distance_flights

        return _cache.get(key=self.user.id, createfunc=update_cache)
Пример #17
0
    def show_event(self, event_id = None):

        if event_id is None:
            redirect(url('show_events'))

        q = DBSession.query(db.Event)
        q = q.filter(db.Event.id == event_id).order_by(db.Event.id)
        event = q.one()

        # As ResultsDB is probably the biggest bottle-neck loading/preparsing data
        # is cached.
        # The current caching implementation can not call methods with arguments
        # so we need to prepare a partial function, with the parameters pre-filled.
        cached_func = partial(rdb_preparse.show_event, self.rdb, event)
        mycache = cache.get_cache('show_event_resultsdb')
        cachedvalue = mycache.get_value(
                        key="event_id_%s" % event_id,
                        createfunc= cached_func,
                        expiretime=10) #FIXME: make the expiretime configurable

        filled = json.loads(request.cookies.get("filled", "{}"))
        return dict(event=event, filled = filled, results = cachedvalue)