Esempio n. 1
0
 def __init__(self, config, **kw):
     try:
         super(Counter, self).__init__(config, **kw)
         self.metadata = MetaData()
         self._connect()
         #TODO: add the most common index.
     except Exception, e:
         logger.log(msg='Could not initialize Storage "%s"' % str(e),
                    type='error', severity=LOG.CRITICAL)
         raise e
Esempio n. 2
0
 def checkService(self, req):
     if req.registry.settings.get('service_until', None):
         # When do we expect the service to be done?"
         delay_until = req.registry.settings.get('service_until')
         # plus a bit of fuzz to dither out the herd
         delay_fuzz = int(req.registry.settings.get('service_fuzz', 30))
         try:
             delay_until = max(int(parser.parse(
                 delay_until).strftime('%s')) - int(time()), 0)
         except ValueError, e:
             logger.log(msg="Could not calculate delay: " + str(e),
                        type="error")
             delay_until = 0
         if delay_until > 0:
             delay_until += random.randrange(0, delay_fuzz)
             raise http.HTTPServiceUnavailable(
                 headers={'Retry-After': str(delay_until)})
Esempio n. 3
0
 def checkService(self, req):
     if req.registry.settings.get('service_until', None):
         # When do we expect the service to be done?"
         delay_until = req.registry.settings.get('service_until')
         # plus a bit of fuzz to dither out the herd
         delay_fuzz = int(req.registry.settings.get('service_fuzz', 30))
         try:
             delay_until = max(
                 int(parser.parse(delay_until).strftime('%s')) -
                 int(time()), 0)
         except ValueError, e:
             logger.log(msg="Could not calculate delay: " + str(e),
                        type="error")
             delay_until = 0
         if delay_until > 0:
             delay_until += random.randrange(0, delay_fuzz)
             raise http.HTTPServiceUnavailable(
                 headers={'Retry-After': str(delay_until)})
Esempio n. 4
0
 def get_announce(self, data, now=None):
     # Really shouldn't allow "global" variables, but I know full well
     # that they're going to want them.
     params = {}
     # The window allows the db to cache the query for the length of the
     # window. This is because the database won't cache a query if it
     # differs from a previous one. The timestamp will cause the query to
     # not be cached.
     #window = int(self.settings.get('db.query_window', 1))
     window = 1
     if now is None:
         now = int(time.time() / window) * window
     sql = ("select created, id, note, priority, `specific`, "
            "start_time, idle_time from %s where " % self.__tablename__ +
            " coalesce(cast(start_time as unsigned), %s) <= %s"
            % (now - 1, now))
     for field in ['product', 'platform', 'channel', 'lang', 'locale']:
         if data.get(field):
             sql += " and coalesce(%s, :%s) = :%s " % (field, field, field)
             params[field] = data.get(field)
     data['idle_time'] = data.get('idle', 0)
     try:
         if 'version' in data:
             sql +=" and coalesce(version, :version) =  :version"
             params['version'] = str(data['version']).split('.')[0]
     except Exception:
         pass
     sql += " and coalesce(idle_time, 0) <= :idle_time "
     params['idle_time'] = data.get('idle_time')
     sql += " order by priority desc, `specific` desc, start_time desc"
     if (self.settings.get('dbg.show_query', False)):
         print sql
         print params
     if (self.settings.get('db.limit')):
         sql += " limit :limit"
         params['limit'] = self.settings.get('db.limit')
     try:
         items = self.engine.execute(text(sql), **dict(params))
     except Exception, e:
         logger.log(msg='SQL Error "%s" ' % str(e),
                    type='error', severity=LOG.CRITICAL)
Esempio n. 5
0
 def _connect(self):
     try:
         userpass = ''
         host = ''
         if (self.settings.get('db.user')):
             userpass = '******' % (self.settings.get('db.user'),
                                    self.settings.get('db.password'))
         if (self.settings.get('db.host')):
             host = '%s' % self.settings.get('db.host')
         dsn = '%s://%s%s/%s' % (self.settings.get('db.type', 'mysql'),
                                 userpass, host,
                                 self.settings.get('db.db',
                                                   self.__database__))
         self.engine = create_engine(dsn, pool_recycle=3600)
         Base.metadata.create_all(self.engine)
         self.session = scoped_session(sessionmaker(bind=self.engine))()
         #self.metadata.create_all(self.engine)
     except Exception, e:
         logger.log(msg='Could not connect to db "%s"' % repr(e),
                    type='error', severity=LOG.EMERGENCY)
         raise e
Esempio n. 6
0
            else:
                return False
        except IOError, e:
            raise e
        except http.HTTPServerError, e:
            raise e
        except Exception, e:
            settings = request.registry.settings
            if utils.strToBool(settings.get('dbg.traceback', False)):
                import traceback
                traceback.print_exc()
            if utils.strToBool(
                    settings.get('dbg.break_unknown_exception', False)):
                import pdb
                pdb.set_trace()
            if logger:
                logger.log(type='error', severity=LOG.ERROR, msg=str(e))
            else:
                import sys
                sys.stderr.write("Auth Error! %s\n", str(e))
            return False
        # User Logged in
        return True

    def __call__(self, *args, **kw):
        for arg in args:
            if isinstance(arg, Request) or isinstance(arg, DummyRequest):
                if self.login(arg):
                    return self.fn(*args, **kw)
        raise http.HTTPUnauthorized(headers={"Refresh": "url=/"})
Esempio n. 7
0
            else:
                return False
        except IOError, e:
            raise e
        except http.HTTPServerError, e:
            raise e
        except Exception, e:
            settings = request.registry.settings
            if utils.strToBool(settings.get('dbg.traceback', False)):
                import traceback
                traceback.print_exc()
            if utils.strToBool(settings.get('dbg.break_unknown_exception',
                                            False)):
                import pdb
                pdb.set_trace()
            if logger:
                logger.log(type='error', severity=LOG.ERROR, msg=str(e))
            else:
                import sys
                sys.stderr.write("Auth Error! %s\n", str(e))
            return False
        # User Logged in
        return True

    def __call__(self, *args, **kw):
        for arg in args:
            if isinstance(arg, Request) or isinstance(arg, DummyRequest):
                if self.login(arg):
                    return self.fn(*args, **kw)
        raise http.HTTPUnauthorized(headers={"Refresh": "url=/"})