class RedisDataSource(AbstractDataSource):
_r = None
def __init__(self,config):
if self._validateConfig(config):
self._r = StrictRedis(host=config[REDIS_DATASOURCE_CONFIG][REDIS_DATASOURCE_CONFIG_HOST],
port=config[REDIS_DATASOURCE_CONFIG][REDIS_DATASOURCE_CONFIG_PORT],
db=config[REDIS_DATASOURCE_CONFIG][REDIS_DATASOURCE_CONFIG_DB])
logger.debug("Obtained internal redis handler" + str(self._r))
else:
raise BaseException("Error validating config ")
def update(self,item):
self.store(item)
def store(self,item):
self._r.set(item.getHash(), item.getValue())
def get(self,item):
return self._r.get(item.getHash())
def exists(self,item):
return self.get(item) is not None
def all(self):
result = []
# Obtain all keys
keys = self._r.keys()
#For each key, get value
for k in keys:
value = self._r.get(k)
result.append(BaseItem({"origin":"redis"},value))
#return result
return result
def _validateConfig(self,config):
validator = MultipleConfigValidator(
{VALIDATORS_LIST:[ContainsKeyConfigValidator({KEY_VALUE:REDIS_DATASOURCE_CONFIG})]})
if not validator.validate(config):
raise BaseException("Config validation error : does not contain " + REDIS_DATASOURCE_CONFIG)
# Validate redis datasource config
validator = MultipleConfigValidator(
{VALIDATORS_LIST:[ContainsKeysConfigValidator({KEYS_LIST:[REDIS_DATASOURCE_CONFIG_DB,
REDIS_DATASOURCE_CONFIG_HOST,
REDIS_DATASOURCE_CONFIG_PORT]})]})
if not validator.validate(config[REDIS_DATASOURCE_CONFIG]):
raise BaseException("Config validation error : config not complete ")
return True
def delete(self,item):
self._r.delete(item.getHash())
class RedisDataSource(AbstractDataSource):
_r = None
def __init__(self, config):
if self._validateConfig(config):
self._r = StrictRedis(
host=config[REDIS_DATASOURCE_CONFIG]
[REDIS_DATASOURCE_CONFIG_HOST],
port=config[REDIS_DATASOURCE_CONFIG]
[REDIS_DATASOURCE_CONFIG_PORT],
db=config[REDIS_DATASOURCE_CONFIG][REDIS_DATASOURCE_CONFIG_DB])
logger.debug("Obtained internal redis handler" + str(self._r))
else:
raise BaseException("Error validating config ")
def update(self, item):
self.store(item)
def store(self, item):
self._r.set(item.getHash(), item.getValue())
def get(self, item):
return self._r.get(item.getHash())
def exists(self, item):
return self.get(item) is not None
def all(self):
result = []
# Obtain all keys
keys = self._r.keys()
#For each key, get value
for k in keys:
value = self._r.get(k)
result.append(BaseItem({"origin": "redis"}, value))
#return result
return result
def _validateConfig(self, config):
validator = MultipleConfigValidator({
VALIDATORS_LIST:
[ContainsKeyConfigValidator({KEY_VALUE: REDIS_DATASOURCE_CONFIG})]
})
if not validator.validate(config):
raise BaseException("Config validation error : does not contain " +
REDIS_DATASOURCE_CONFIG)
# Validate redis datasource config
validator = MultipleConfigValidator({
VALIDATORS_LIST: [
ContainsKeysConfigValidator({
KEYS_LIST: [
REDIS_DATASOURCE_CONFIG_DB,
REDIS_DATASOURCE_CONFIG_HOST,
REDIS_DATASOURCE_CONFIG_PORT
]
})
]
})
if not validator.validate(config[REDIS_DATASOURCE_CONFIG]):
raise BaseException(
"Config validation error : config not complete ")
return True
def delete(self, item):
self._r.delete(item.getHash())
from redis.client import StrictRedis
if __name__ == '__main__':
strict_redis = StrictRedis(host='127.0.0.1',
port=6379,
db=0,
decode_responses=True)
strict_redis.set('aa', '111')
strict_redis.set('bb', '222')
strict_redis.set('cc', '333')
aa = strict_redis.get('aa')
bb = strict_redis.get('bb')
cc = strict_redis.get('cc')
dd = strict_redis.get('dd')
print(aa, bb, cc)
keys = strict_redis.keys()
print(keys, type(keys))
class RedisStore():
def __init__(self, db_host, db_port, db_num, db_pw):
pool = ConnectionPool(max_connections=2, db=db_num, host=db_host, port=db_port, password=db_pw)
self.redis = StrictRedis(connection_pool=pool)
self.class_map = {}
self.object_map = {}
def create_object(self, dbo, update_rev=False):
self.save_object(dbo, update_rev)
dbo.on_loaded()
def save_object(self, dbo, update_rev=False, autosave=False):
if update_rev:
rev = getattr(dbo, "dbo_rev", None)
dbo.dbo_rev = 1 if not rev else rev + 1
dbo.before_save()
key = dbo.dbo_key
self.redis.set(key, self.json_encode(dbo.save_json_obj))
if dbo.dbo_set_key:
self.redis.sadd(dbo.dbo_set_key, key)
self.dispatch("db_log{0}".format("_auto" if autosave else ""), "object saved: " + key)
self.object_map[dbo.dbo_key] = dbo
def load_cached(self, key):
return self.object_map.get(key)
def evict_object(self, dbo):
try:
del self.object_map[dbo.dbo_key]
except:
debug("Failed to evict " + dbo.dbo_key + " from db cache", self)
@logged
def load_by_key(self, key_type, key, base_class=None):
dbo_key = unicode('{0}:{1}'.format(key_type, key))
cached_dbo = self.object_map.get(dbo_key)
if cached_dbo:
return cached_dbo
json_str = self.redis.get(dbo_key)
if not json_str:
return None
json_obj = self.json_decode(json_str)
dbo = self._load_class(json_obj, base_class)(key)
if dbo.dbo_key_type:
self.object_map[dbo.dbo_key] = dbo
self.load_json(dbo, json_obj)
return dbo
def object_exists(self, obj_type, obj_id):
key = unicode('{0}:{1}'.format(obj_type, obj_id))
return key in self.redis.keys(key)
def load_object(self, dbo_class, key):
return self.load_by_key(dbo_class.dbo_key_type, key, dbo_class)
def update_object(self, dbo, json_obj):
self.load_json(dbo, json_obj)
self.save_object(dbo, True)
def delete_object(self, dbo):
key = dbo.dbo_key
self.redis.delete(key)
if dbo.dbo_set_key:
self.redis.srem(dbo.dbo_set_key, key)
for dbo_col in dbo.dbo_collections:
if dbo_col.key_type:
coll = getattr(dbo, dbo_col.field_name, set())
for child_dbo in coll:
self.delete_object(child_dbo)
debug("object deleted: " + key, self)
if self.object_map.get(dbo.dbo_key):
del self.object_map[dbo.dbo_key]
return True
def fetch_set_keys(self, set_key):
return self.redis.smembers(set_key)
def set_index(self, index_name, key, value):
return self.redis.hset(index_name, key, value)
def get_index(self, index_name, key):
return self.redis.hget(index_name, key)
def delete_index(self, index_name, key):
return self.redis.hdel(index_name, key)
def _load_class(self, json_obj, base_class):
class_path = json_obj.get("class_name")
if not class_path:
return self.cls_registry(base_class)
clazz = self.class_map.get(class_path)
if clazz:
return clazz
split_path = class_path.split(".")
module_name = ".".join(split_path[:-1])
class_name = split_path[-1]
module = __import__(module_name, globals(), locals(), [class_name])
clazz = getattr(module, class_name)
clazz = self.cls_registry(clazz)
self.class_map[class_path] = clazz
return clazz
def load_json(self, dbo, json_obj):
for field_name in dbo.dbo_fields:
try:
setattr(dbo, field_name, json_obj[field_name])
except KeyError:
pass
for dbo_col in dbo.dbo_collections:
coll = getattr(dbo, dbo_col.field_name, [])
try:
for child_json in json_obj[dbo_col.field_name]:
try:
if dbo_col.key_type:
child_dbo = self.load_by_key(dbo_col.key_type, child_json, dbo_col.base_class)
else:
child_dbo = self._load_class(child_json, dbo_col.base_class)()
self.load_json(child_dbo, child_json)
coll.append(child_dbo)
except AttributeError:
warn("{0} json failed to load for coll {1} in {2}".format(child_json, dbo_col.field_name, unicode(dbo.dbo_id)), self)
except KeyError:
if dbo.dbo_key_type:
trace("db: Object " + unicode(dbo.dbo_debug_key) + " json missing collection " + dbo_col.field_name, self)
for dbo_ref in dbo.dbo_refs:
try:
ref_key = json_obj[dbo_ref.field_name]
ref_obj = self.load_by_key(dbo_ref.key_type, ref_key, dbo_ref.base_class)
setattr(dbo, dbo_ref.field_name, ref_obj)
except:
if dbo.dbo_key_type:
trace("db: Object " + unicode(dbo.dbo_debug_key) + " json missing ref " + dbo_ref.field_name, self)
dbo.on_loaded()
return True
class MainWindow(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Redis Explorer")
self.resize(QtWidgets.QDesktopWidget().availableGeometry(self).size() * 0.5)
self.tree = QtWidgets.QTreeWidget()
self.label = QtWidgets.QTextEdit()
font = self.label.font()
font.setPointSize(12)
self.label.setFont(font)
self.tree.setColumnCount(2)
self.tree.header().setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents)
self.tree.setHeaderHidden(True)
splitter = QtWidgets.QSplitter()
splitter.addWidget(self.tree)
scroll_area = QtWidgets.QScrollArea()
scroll_area.setWidgetResizable(True)
scroll_area.setWidget(self.label)
splitter.addWidget(scroll_area)
splitter.setSizes([1, 1])
self.setCentralWidget(splitter)
toolbar = self.addToolBar("")
toolbar.setMovable(False)
toolbar.setIconSize(QtCore.QSize(32, 32))
toolbar.addAction(QtGui.QIcon("resources/list-add.png"), "").triggered.connect(lambda: self.plus_font(1))
toolbar.addAction(QtGui.QIcon("resources/list-remove.png"), "").triggered.connect(lambda: self.plus_font(-1))
toolbar.addAction(QtGui.QIcon("resources/view-refresh.png"), "").triggered.connect(lambda: self.refresh())
self.redis = StrictRedis()
def item_clicked(item: QtWidgets.QTreeWidgetItem):
if item.parent() is None:
return
value = self.redis.get(item.text(0))
value = value.decode()
text = json.dumps(json.loads(value), ensure_ascii=False, indent=4)
text = text.replace(" ", " ").replace("\n", "<br/>").replace(":", "<font color=red>:</font>")
text = re.sub(r'"(.*?)(?<!\\)"', r'<font color=green>"\g<1>"</font>', text)
self.label.setHtml(text)
self.tree.itemClicked.connect(item_clicked)
def plus_font(self, number: int):
font = self.label.font()
font.setPointSize(font.pointSize() + number)
self.label.setFont(font)
def refresh(self):
self.tree.clear()
self.label.setPlainText("")
keys = sorted(self.redis.keys("*"))
keys = [x.decode() for x in keys]
dct = dict()
for key in keys:
parts = key.split(":")
prefix = parts[0]
if prefix not in dct:
dct[prefix] = [key]
else:
dct[prefix].append(key)
for prefix, keys in dct.items():
item = QtWidgets.QTreeWidgetItem([prefix])
for key in keys:
item.addChild(QtWidgets.QTreeWidgetItem([key]))
self.tree.addTopLevelItem(item)
def showEvent(self, event: QtGui.QShowEvent):
super().showEvent(event)
self.refresh()
