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()