def has_storage():
result = False
try:
store = Store(connect_timeout=2, attempts=2)
store.connect()
result = True
except redis.ConnectionError:
pass
return result
class StorageTest(unittest.TestCase):
def setUp(self):
self.store = Store(connect_timeout=5, attempts=3)
def test_on_disconnected_store_cache_set_cache_get(self):
self.store = Store(port=9999, connect_timeout=1, attempts=1)
key = "uid:c20ad4d76fe97759aa27a0c99bff6710"
self.store.cache_set(key, -1, 60)
value = self.store.cache_get(key) or 0
self.assertEqual(value, 0)
@cases([{
'key': "uid:123456",
'value': 1
}, {
'key': "uid:123456",
'value': -3.7
}])
def test_on_connected_store_get_cache_get(self, kwargs):
self.store.connect()
key = kwargs['key']
self.store.cache_set(key, kwargs['value'], 60 * 60)
value = self.store.cache_get(key) or 0
self.assertEqual(value, kwargs['value'])
@cases([{
'key': "uid:654321",
'value': 'books'
}, {
'key': "uid:654321",
'value': 'путешествие'
}])
def test_on_connected_store_get(self, kwargs):
self.store.connect()
key = kwargs['key']
self.store.redis.delete(key)
self.store.redis.rpush(key, kwargs['value'])
value = self.store.get(key) or None
self.assertEqual(value, [kwargs['value']])
class TestStore(unittest.TestCase):
def setUp(self):
self.redis_storage = RedisStore(host=os.getenv('REDIS_HOST',
'localhost'),
port=os.getenv('REDIS_PORT', 6379))
self.store = Store(self.redis_storage)
self.store.connect()
self.key = 'sample_key'
self.value = 'sample_value'
def test_connect_to_store(self):
self.assertTrue(self.store.ping())
def test_connect_to_redis(self):
self.assertTrue(self.redis_storage.ping())
def test_redis_set_value(self):
key = self.key + '_redis'
self.assertTrue(self.redis_storage.set(key, self.value, 30))
self.assertEqual(self.store.cache_get(key), self.value)
def test_redis_connection_error(self):
self.redis_storage.client.disconnect()
self.assertRaises(ConnectionError, self.store.cache_get, self.key)
def test_cache_set_value(self):
key = self.key + '_cache'
self.assertTrue(self.store.cache_set(key, self.value, 30))
self.assertEqual(self.store.cache_get(key), self.value)
def test_cache_connection_error(self):
self.redis_storage.client.disconnect()
self.assertRaises(ConnectionError, self.store.cache_get, self.key)
self.assertRaises(ConnectionError, self.store.cache_set, self.key,
self.value)
def test_store_set_value(self):
key = self.key + '_store'
self.assertTrue(self.store.set(key, self.value, 30))
self.assertEqual(self.store.get(key), self.value)
class Session(IFilter):
MAGGC = '^&*)('
MAGIC = ')(*&^'
MAGGCL = len(MAGGC)
MAGICL = len(MAGIC)
S_None = 0
S_Prefix = 1
PT_PURIFY = 1
PT_PROTO = 2
def __init__(self, sock, address):
IFilter.__init__(self)
self.logger = logging.getLogger("Session")
self.sock = sock
self.addr = address
self.buffer = ""
self.status = Session.S_None
if not self.init_db(): raise "redis connection failed."
if not self.init_manager(): raise "install chain manager failed."
def init_db(self):
self.store = Store("10.10.69.54")
return self.store.connect()
def getStore(self):
if not hasattr(self, store):
return None
return self.store
def init_manager(self):
self.cm = ChainManager(self)
return self.cm.install()
def process(self, data):
print data
print "==============================="
'''
status should be 0 =====> 1 by find MAGGC
1 =====> 0 by find MAGIC and buffer length less then 1M, we don't support 1M purify maybe.
let me take consider about this state machine.eh?
'''
while data and len(data) > 0:
if Session.S_None == self.status:
idx = data.find(Session.MAGGC)
if idx == -1:
break
else:
self.status = Session.S_Prefix
data = data[idx + Session.MAGGCL:]
if len(data) == 0: break
if Session.S_Prefix == self.status:
idx = data.find(Session.MAGIC)
if -1 != idx:
offset = 0
ggc = data.find(Session.MAGGC)
self.status = Session.S_None
if ggc != -1 and ggc < idx:
self.buffer = ''
offset = gcc + Session.MAGGCL
idx = idx - len(data)
rtn = self.buffer + data[offset:idx]
# really output.........
self.logger.debug(rtn)
self.dispatch(rtn)
data = data[idx + len(Session.MAGIC):] #jump magic chars
self.buffer = ''
else:
ggc = string.rfind(data, Session.MAGGC)
if ggc != -1:
self.buffer = data[(gcc + Session.MAGGCL):]
else:
self.buffer += data
break
else:
self.logger.error("impossible state of Session.")
def dispatch(self, packet):
'''
dispatch the string packet to specified Chain in our system
'''
if not packet:
return
fields = packet.strip().split('$$')
size = len(fields)
if size < 2:
return
protocol_type = int(fields[0])
if protocol_type < 0 or protocol_type > 9999:
return
if protocol_type == Session.PT_PURIFY:
# simple dispatch to readability
print "====== simply dispatch to readability. ======"
#check the count of parameters
if size < 3:
self.logger.error("protocol type (%d), parameter count error:(%d)", protocol_type, size)
return
if not self.cm.determin(fields[1], content = fields[2]):
self.logger.error("determin domain:(%s) error: [%s]", fields[1], fields[2])
elif protocol_type == Session.PT_PROTO:
self.logger.debug("request is a protocol. type:%d command:%s" % (protocol_type, fields[1]))
return
def onProcess(self, request):
IFilter.onProcess(self, request)
self.logger.debug("SessionFilter onProcess...")
try:
if request.error:
self.sock.send('1$$Error:%s' %(request.error, ))
else:
if not request.result: request.result = ''
self.sock.send('0$$%s' % (request.result, ))
except Exception, e:
self.logger.error("Error: %s " % (e, ))
