Python models.MStatistics类代码示例

 def calculate_metrics(self):
     from apps.statistics.models import MStatistics
     
     return {
         'feed_loadtimes_avg_hour': MStatistics.get('latest_avg_time_taken'),
         'feeds_loaded_hour': MStatistics.get('latest_sites_loaded'),
     }

 def run(self, feed_pks, **kwargs):
     from apps.rss_feeds.models import Feed
     from apps.statistics.models import MStatistics
     
     mongodb_replication_lag = int(MStatistics.get('mongodb_replication_lag', 0))
     compute_scores = bool(mongodb_replication_lag < 10)
     
     options = {
         'fake': bool(MStatistics.get('fake_fetch')),
         'quick': float(MStatistics.get('quick_fetch', 0)),
         'compute_scores': compute_scores,
         'mongodb_replication_lag': mongodb_replication_lag,
     }
     
     if not isinstance(feed_pks, list):
         feed_pks = [feed_pks]
         
     for feed_pk in feed_pks:
         try:
             feed = Feed.get_by_id(feed_pk)
             if not feed:
                 raise Feed.DoesNotExist
             feed.update(**options)
         except Feed.DoesNotExist:
             logging.info(" ---> Feed doesn't exist: [%s]" % feed_pk)

    def run(self, feed_pks, **kwargs):
        from apps.rss_feeds.models import Feed
        from apps.statistics.models import MStatistics
        r = redis.Redis(connection_pool=settings.REDIS_FEED_UPDATE_POOL)

        mongodb_replication_lag = int(MStatistics.get('mongodb_replication_lag', 0))
        compute_scores = bool(mongodb_replication_lag < 10)
        
        profiler = DBProfilerMiddleware()
        profiler_activated = profiler.process_celery()
        if profiler_activated:
            mongo_middleware = MongoDumpMiddleware()
            mongo_middleware.process_celery(profiler)
            redis_middleware = RedisDumpMiddleware()
            redis_middleware.process_celery(profiler)
        
        options = {
            'quick': float(MStatistics.get('quick_fetch', 0)),
            'updates_off': MStatistics.get('updates_off', False),
            'compute_scores': compute_scores,
            'mongodb_replication_lag': mongodb_replication_lag,
        }
        
        if not isinstance(feed_pks, list):
            feed_pks = [feed_pks]
            
        for feed_pk in feed_pks:
            feed = Feed.get_by_id(feed_pk)
            if not feed or feed.pk != int(feed_pk):
                logging.info(" ---> ~FRRemoving feed_id %s from tasked_feeds queue, points to %s..." % (feed_pk, feed and feed.pk))
                r.zrem('tasked_feeds', feed_pk)
            if feed:
                feed.update(**options)
                if profiler_activated: profiler.process_celery_finished()

    def run(self, feed_pks, **kwargs):
        from apps.rss_feeds.models import Feed
        from apps.statistics.models import MStatistics
        r = redis.Redis(connection_pool=settings.REDIS_FEED_POOL)

        mongodb_replication_lag = int(MStatistics.get('mongodb_replication_lag', 0))
        compute_scores = bool(mongodb_replication_lag < 10)
        
        options = {
            'quick': float(MStatistics.get('quick_fetch', 0)),
            'updates_off': MStatistics.get('updates_off', False),
            'compute_scores': compute_scores,
            'mongodb_replication_lag': mongodb_replication_lag,
        }
        
        if not isinstance(feed_pks, list):
            feed_pks = [feed_pks]
            
        for feed_pk in feed_pks:
            feed = Feed.get_by_id(feed_pk)
            if not feed or feed.pk != int(feed_pk):
                logging.info(" ---> ~FRRemoving feed_id %s from tasked_feeds queue, points to %s..." % (feed_pk, feed and feed.pk))
                r.zrem('tasked_feeds', feed_pk)
            if feed:
                feed.update(**options)

 def calculate_metrics(self):
     from apps.statistics.models import MStatistics
     
     return {
         'sql_avg': MStatistics.get('latest_sql_avg'),
         'mongo_avg': MStatistics.get('latest_mongo_avg'),
         'redis_avg': MStatistics.get('latest_redis_avg'),
     }

 def handle(self, *args, **options):
     if options['daemonize']:
         daemonize()
     
     settings.LOG_TO_STREAM = True
     now = datetime.datetime.utcnow()
     
     if options['skip']:
         feeds = Feed.objects.filter(next_scheduled_update__lte=now,
                                     average_stories_per_month__lt=options['skip'],
                                     active=True)
         print " ---> Skipping %s feeds" % feeds.count()
         for feed in feeds:
             feed.set_next_scheduled_update()
             print '.',
         return
         
     socket.setdefaulttimeout(options['timeout'])
     if options['force']:
         feeds = Feed.objects.all()
     elif options['username']:
         feeds = Feed.objects.filter(subscribers__user=User.objects.get(username=options['username']))
     elif options['feed']:
         feeds = Feed.objects.filter(pk=options['feed'])
     else:
         feeds = Feed.objects.filter(next_scheduled_update__lte=now, active=True)
     
     feeds = feeds.order_by('?')
     
     for f in feeds:
         f.set_next_scheduled_update()
     
     num_workers = min(len(feeds), options['workerthreads'])
     if options['single_threaded']:
         num_workers = 1
     
     options['compute_scores'] = True
     options['quick'] = float(MStatistics.get('quick_fetch', 0))
     options['updates_off'] = MStatistics.get('updates_off', False)
     
     disp = feed_fetcher.Dispatcher(options, num_workers)        
     
     feeds_queue = []
     for _ in range(num_workers):
         feeds_queue.append([])
     
     i = 0
     for feed in feeds:
         feeds_queue[i%num_workers].append(feed.pk)
         i += 1
     disp.add_jobs(feeds_queue, i)
     
     django.db.connection.close()
     
     print " ---> Fetching %s feeds..." % feeds.count()
     disp.run_jobs()

    def run(self, feed_pks, **kwargs):
        from apps.rss_feeds.models import Feed
        from apps.statistics.models import MStatistics

        options = {"fake": bool(MStatistics.get("fake_fetch")), "quick": float(MStatistics.get("quick_fetch", 0))}

        if not isinstance(feed_pks, list):
            feed_pks = [feed_pks]

        for feed_pk in feed_pks:
            try:
                feed = Feed.objects.get(pk=feed_pk)
                feed.update(options=options)
            except Feed.DoesNotExist:
                logging.info(" ---> Feed doesn't exist: [%s]" % feed_pk)

 def calculate_metrics(self):
     from apps.statistics.models import MStatistics
     statistics = MStatistics.all()
 
     return {
         'feed_success': statistics['feeds_fetched'],
     }

def dashboard_graphs(request):
    statistics = MStatistics.all()
    return render_to_response(
        "statistics/render_statistics_graphs.xhtml",
        {"statistics": statistics},
        context_instance=RequestContext(request),
    )

 def run(self, feed_id, xml, **kwargs):
     from apps.rss_feeds.models import Feed
     from apps.statistics.models import MStatistics
     
     mongodb_replication_lag = int(MStatistics.get('mongodb_replication_lag', 0))
     compute_scores = bool(mongodb_replication_lag < 60)
     
     options = {
         'feed_xml': xml,
         'compute_scores': compute_scores,
         'mongodb_replication_lag': mongodb_replication_lag,
     }
     feed = Feed.get_by_id(feed_id)
     feed.update(options=options)

    def run(self, feed_pks, **kwargs):
        from apps.rss_feeds.models import Feed
        from apps.statistics.models import MStatistics

        mongodb_replication_lag = int(MStatistics.get("mongodb_replication_lag", 0))
        compute_scores = bool(mongodb_replication_lag < 10)

        options = {
            "fake": bool(MStatistics.get("fake_fetch")),
            "quick": float(MStatistics.get("quick_fetch", 0)),
            "compute_scores": compute_scores,
            "mongodb_replication_lag": mongodb_replication_lag,
        }

        if not isinstance(feed_pks, list):
            feed_pks = [feed_pks]

        for feed_pk in feed_pks:
            try:
                feed = Feed.get_by_id(feed_pk)
                feed.update(**options)
            except Feed.DoesNotExist:
                logging.info(" ---> Feed doesn't exist: [%s]" % feed_pk)

 def run(self, feed_pks, **kwargs):
     from apps.rss_feeds.models import Feed
     from apps.statistics.models import MStatistics
     
     fake = bool(MStatistics.get('fake_fetch'))
     
     if not isinstance(feed_pks, list):
         feed_pks = [feed_pks]
         
     for feed_pk in feed_pks:
         try:
             feed = Feed.objects.get(pk=feed_pk)
             feed.update(fake=fake)
         except Feed.DoesNotExist:
             logging.info(" ---> Feed doesn't exist: [%s]" % feed_pk)

def index(request):
    if request.method == "POST":
        if request.POST['submit'] == 'login':
            login_form = LoginForm(request.POST, prefix='login')
            signup_form = SignupForm(prefix='signup')
        else:
            login_form = LoginForm(prefix='login')
            signup_form = SignupForm(request.POST, prefix='signup')
    else:
        login_form = LoginForm(prefix='login')
        signup_form = SignupForm(prefix='signup')
    
    user = get_user(request)
    features = Feature.objects.all()[:3]
    feature_form = None
    if request.user.is_staff:
        feature_form = FeatureForm()

    feed_count = 0
    active_count = 0
    train_count = 0
    if request.user.is_authenticated():
        feed_count = UserSubscription.objects.filter(user=request.user).count()
        active_count = UserSubscription.objects.filter(user=request.user, active=True).count()
        train_count = UserSubscription.objects.filter(user=request.user, active=True, is_trained=False, feed__stories_last_month__gte=1).count()
    
    now = datetime.datetime.now()
    recommended_feeds = RecommendedFeed.objects.filter(is_public=True, approved_date__lte=now).select_related('feed')[:2]
    # recommended_feed_feedback = RecommendedFeedUserFeedback.objects.filter(recommendation=recommended_feed)

    statistics = MStatistics.all()
    howitworks_page = 0 # random.randint(0, 5)
    return render_to_response('reader/feeds.xhtml', {
        'user_profile': user.profile,
        'login_form': login_form,
        'signup_form': signup_form,
        'feature_form': feature_form,
        'features': features,
        'start_import_from_google_reader': request.session.get('import_from_google_reader', False),
        'howitworks_page': howitworks_page,
        'feed_count': feed_count,
        'active_count': active_count,
        'train_count': active_count - train_count,
        'account_images': range(1, 4),
        'recommended_feeds': recommended_feeds,
        'statistics': statistics,
        # 'recommended_feed_feedback': recommended_feed_feedback,
    }, context_instance=RequestContext(request))

def welcome(request, **kwargs):
    user = get_user(request)
    statistics = MStatistics.all()
    social_profile = MSocialProfile.get_user(user.pk)

    if request.method == "POST":
        pass
    else:
        login_form = LoginForm(prefix='login')
        signup_form = SignupForm(prefix='signup')

    return {
        'user_profile': hasattr(user, 'profile') and user.profile,
        'login_form': login_form,
        'signup_form': signup_form,
        'statistics': statistics,
        'social_profile': social_profile,
        'post_request': request.method == 'POST'
    }, "reader/welcome.xhtml"

def index(request):
    if request.method == "POST":
        if request.POST['submit'] == 'login':
            login_form  = LoginForm(request.POST, prefix='login')
            signup_form = SignupForm(prefix='signup')
        else:
            login_form  = LoginForm(prefix='login')
            signup_form = SignupForm(request.POST, prefix='signup')
    else:
        login_form  = LoginForm(prefix='login')
        signup_form = SignupForm(prefix='signup')
    
    user         = get_user(request)
    authed       = request.user.is_authenticated()
    features     = Feature.objects.all()[:3]
    feature_form = FeatureForm() if request.user.is_staff else None
    feed_count   = UserSubscription.objects.filter(user=request.user).count() if authed else 0
    active_count = UserSubscription.objects.filter(user=request.user, active=True).count() if authed else 0
    train_count  = UserSubscription.objects.filter(user=request.user, active=True, is_trained=False, feed__stories_last_month__gte=1).count() if authed else 0
    recommended_feeds = RecommendedFeed.objects.filter(is_public=True, approved_date__lte=datetime.datetime.now()).select_related('feed')[:2]
    unmoderated_feeds = RecommendedFeed.objects.filter(is_public=False, declined_date__isnull=True).select_related('feed')[:2]
    statistics   = MStatistics.all()
    feedbacks    = MFeedback.all()
    start_import_from_google_reader = request.session.get('import_from_google_reader', False)
    if start_import_from_google_reader:
        del request.session['import_from_google_reader']

    return render_to_response('reader/feeds.xhtml', {
        'user_profile'      : hasattr(user, 'profile') and user.profile,
        'login_form'        : login_form,
        'signup_form'       : signup_form,
        'feature_form'      : feature_form,
        'features'          : features,
        'feed_count'        : feed_count,
        'active_count'      : active_count,
        'train_count'       : active_count - train_count,
        'account_images'    : range(1, 4),
        'recommended_feeds' : recommended_feeds,
        'unmoderated_feeds' : unmoderated_feeds,
        'statistics'        : statistics,
        'feedbacks'         : feedbacks,
        'start_import_from_google_reader': start_import_from_google_reader,
    }, context_instance=RequestContext(request))