+ 

+ from .utils import cache_utils

+ CACHE = cache_utils.Cached(max_cache_age=app.config['MAX_DB_AGE'])

+ 

+ 

+ from oraculum import db, CACHE

+ from oraculum.controllers.main import register_cache_providers

+ from oraculum.data_providers import PROVIDERS

+ from oraculum.models.db_cache import CachedData

+     db.session.query(CachedData).delete()

+     db.session.commit()

+ 

+     register_cache_providers()

+     for r in CACHE._refreshers:

+         CACHE._refresh(r)

+ from oraculum import app, login_manager, oidc, CACHE

+ from oraculum.utils import fedocal, schedule, blockerbugs, meetbot, cache_utils, libkarma

+ 

+ @app.before_first_request

+ def register_cache_providers():

+     """

+     Add providers to be cached here

+     """

+     app.logger.debug('Registering cache refreshers')

+     CACHE.register('landing_page', api_v1_landing_page)

+     CACHE.register('bodhi', api_v1_all_bodhi_updates)

+     for p_name, p_module in PROVIDERS.items():

+         CACHE.register(p_name, p_module.get_actions)

+     landing_page = CACHE.get('landing_page')

+         return jsonify(CACHE.get('bodhi')["F" + release])

+         return jsonify(CACHE.get('bodhi'))

+     return jsonify({'error': 'Release %s not found' % release}), 404

+ 

+ def api_v1_all_bodhi_updates():

+     landing_page = CACHE.get('landing_page')

+     current_releases = [str(i) for i in [(landing_page["stable"] - 1), landing_page["stable"], landing_page["devel"]]]

+     updates = {}

+     for single_release in current_releases:

+         app.logger.debug("Appending updates for release: %s" % single_release)

+         updates["F" + single_release] = libkarma.get_updates(single_release, app.logger)

+     return updates

+     return jsonify(CACHE.get('landing_page'))

+     return {

+         actions.extend(CACHE.get(p_name))

+ import json

+ 

+         self._parsed_raw_text = None

+ 

+     @property

+     def data(self):

+         try:

+             if self._parsed_raw_text is None:

+                 self._parsed_raw_text = json.loads(self.raw_text)

+         except AttributeError:

+                 self._parsed_raw_text = json.loads(self.raw_text)

+         return self._parsed_raw_text

+ #

+ # cache_utils.py - Database helper functions landing page cache

+ #

+ # Copyright 2020, Red Hat, Inc

+ #

+ # This program is free software; you can redistribute it and/or modify

+ # it under the terms of the GNU General Public License as published by

+ # the Free Software Foundation; either version 2 of the License, or

+ # (at your option) any later version.

+ #

+ # This program 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 General Public License for more details.

+ #

+ # You should have received a copy of the GNU General Public License along

+ # with this program; if not, write to the Free Software Foundation, Inc.,

+ # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+ #

+ # Authors:

+ #   Frantisek Zatloukal <fzatlouk@redhat.com>

+ #   Josef Skladanka <jskladan@redhat.com>

+ 

+ import datetime

+ import json

+ 

+ from oraculum import app, db

+ from oraculum.models.db_cache import CachedData

+ 

+ class CachedObject():

+     def __init__(self, time_created, data):

+         self.time_created = time_created

+         self.data = data

+ 

+ class Cached():

+     def __init__(self, max_cache_age):

+         self._refreshers = {}

+         self._local_cache = {}

+         self._max_cache_age = datetime.timedelta(seconds=max_cache_age)

+ 

+     # getting the values

+     @property

+     def max_cache_age(self):

+         return self._max_cache_age

+ 

+     # setting the values

+     @max_cache_age.setter

+     def max_cache_age(self, value):

+         self._max_cache_age = datetime.timedelta(seconds=value)

+ 

+     def register(self, what, refresh_method):

+         self._refreshers[what] = refresh_method

+ 

+     def get(self, what):

+         if what not in self._refreshers:

+             raise Exception

+ 

+         if self._new_enough(self._local_cache.get(what)):

+             app.logger.debug("_local_cache cache hit on %s" % what)

+             return self._local_cache[what].data

+ 

+         app.logger.debug("_local_cache miss on %s" % what)

+ 

+         from_db = CachedData.query.filter_by(provider=what).first()

+         if not from_db or not self._new_enough(from_db):

+             app.logger.debug("db cache miss on %s" % what)

+             self._refresh(what)

+         else:

+             app.logger.debug("db cache hit on %s" % what)

+             self._local_cache[what] = CachedObject(from_db.time_created, from_db.data)

+ 

+         return self._local_cache[what].data

+ 

+     def _new_enough(self, cached_object):

+         if cached_object is None:

+             return False

+         if app.config['FORCE_CACHED_DATA']:

+             return True

+         if datetime.datetime.utcnow() > cached_object.time_created + self.max_cache_age:

+             return False

+         return True

+ 

+     def _refresh(self, what):

+         row = CachedData.query.filter_by(provider=what).first()

+ 

+         data = self._refreshers[what]()

+ 

+         if row:

+             row.time_created = datetime.datetime.utcnow()

+             row.raw_text = json.dumps(data)

+         else:

+             row = CachedData(what, json.dumps(data))

+             db.session.add(row)

+ 

+         db.session.commit()

+         self._local_cache[what] = CachedObject(row.time_created, data)

+ 

+ if __name__ == "__main__":

+     CACHE = Cached(max_cache_age=300)

+     import ipdb; ipdb.set_trace()

+     """

+     CACHE.register('bodhi', libkarma.get_all_updates)

+ 

+     print("- Getting bodhi")

+     test = CACHE.get('bodhi')

+     """