buzzboard/queues.py at master · tracer0tong/buzzboard · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import pickle

import redis

from settings import REDIS_QUEUE, REDIS_PREFIX


class LearningQueue(object):
    LearningQueuePrefix = 'lq'

    def __init__(self, host, db, prefix):
        self.host = host
        self.db = db
        self.prefix = prefix + self.LearningQueuePrefix
        self.redis = redis.StrictRedis(self.host, db=self.db)

    def save_features(self, uuid, features):
        self.redis.hset(self.prefix, uuid, pickle.dumps(features))

    def load_features(self, uuid=None):
        if uuid:
            features = [pickle.loads(self.redis.hget(self.prefix, uuid))]
        else:
            features = [pickle.loads(x) for x in self.redis.hvals(self.prefix)]
        return features

    def count_items(self, uuid=None):
        if uuid:
            pass
        else:
            return self.redis.hlen(self.prefix)

    def clean(self):
        self.redis.delete(self.prefix)


class MessageQueue(object):
    MessageQueuePrefix = 'mq'
    MessageQueueLookdown = 15

    def __init__(self, host, db, prefix):
        self.host = host
        self.db = db
        self.prefix = prefix + self.MessageQueuePrefix
        self.redis = redis.StrictRedis(self.host, db=self.db)

    def save_message(self, uuid, message):
        self.redis.lpush(self.prefix, pickle.dumps((uuid, message)))

    def load_messages(self, uuid=None):
        messages = [pickle.loads(x) for x in self.redis.lrange(self.prefix, 0, self.MessageQueueLookdown)]
        return messages

    def clean(self):
        self.redis.delete(self.prefix)


class CaptchaQueue(object):
    CaptchaQueuePrefix = 'cq'
    RedirectsPrefix = 'r'
    ProvesPrefix = 'p'
    AttemptsRefix = 'a'

    def __init__(self, host, db, prefix):
        self.host = host
        self.db = db
        self.prefix = prefix + self.CaptchaQueuePrefix
        self.redis = redis.StrictRedis(self.host, db=self.db)

    def check_event(self, uuid, redirect_to):
        pipe = self.redis.pipeline()
        pipe.set(self.prefix + self.RedirectsPrefix + uuid, redirect_to)
        pipe.set(self.prefix + self.AttemptsRefix + uuid, 0)
        pipe.set(self.prefix + self.ProvesPrefix + uuid, 0)
        pipe.execute()

    def prove_event(self, uuid):
        pipe = self.redis.pipeline()
        pipe.incr(self.prefix + self.AttemptsRefix + uuid)
        pipe.set(self.prefix + self.ProvesPrefix + uuid, 1)
        pipe.execute()

    def failed_event(self, uuid):
        pipe = self.redis.pipeline()
        pipe.incr(self.prefix + self.AttemptsRefix + uuid)
        pipe.set(self.prefix + self.ProvesPrefix + uuid, 0)
        pipe.execute()

    def delete_check(self, uuid):
        pipe = self.redis.pipeline()
        pipe.delete(self.prefix + self.RedirectsPrefix + uuid)
        pipe.delete(self.prefix + self.AttemptsRefix + uuid)
        pipe.delete(self.prefix + self.ProvesPrefix + uuid)
        pipe.execute()

    def get_redirect(self, uuid):
        return self.redis.get(self.prefix + self.RedirectsPrefix + uuid)

    def get_result(self, uuid):
        if int(self.redis.get(self.prefix + self.ProvesPrefix + uuid)) == 0:
            res = False
        else:
            res = True
        return res, int(self.redis.get(self.prefix + self.AttemptsRefix + uuid))

    def exists(self, uuid):
        return self.redis.exists(self.prefix + self.ProvesPrefix + uuid)

    def clean(self):
        self.redis.delete(self.prefix)


cq = CaptchaQueue(REDIS_QUEUE['host'], REDIS_QUEUE['db'], REDIS_PREFIX)
lq = LearningQueue(REDIS_QUEUE['host'], REDIS_QUEUE['db'], REDIS_PREFIX)
mq = MessageQueue(REDIS_QUEUE['host'], REDIS_QUEUE['db'], REDIS_PREFIX)