def create_redis_connection(): logging.debug("Creating Redis connection (%s)", settings.REDIS_URL) redis_url = urlparse.urlparse(settings.REDIS_URL) if redis_url.scheme == 'redis+socket': qs = urlparse.parse_qs(redis_url.query) if 'virtual_host' in qs: db = qs['virtual_host'][0] else: db = 0 client = walrus.Database(unix_socket_path=redis_url.path, db=db) else: if redis_url.path: redis_db = redis_url.path[1] else: redis_db = 0 # Redis passwords might be quoted with special characters redis_password = redis_url.password and urllib.unquote( redis_url.password) client = walrus.Database(host=redis_url.hostname, port=redis_url.port, db=redis_db, password=redis_password) return client
def __init__(self): configfile = os.environ['QWC_CONFIG_FILE'] config = ConfigObj(configfile) self.redisdb = walrus.Database(host=config['redis']['host'], port=config['redis']['port'], password=config['redis']['password'], db=config['redis']['db'])
def setup(self): self.redis_client = walrus.Database().from_url(config.get("REDIS_URL")) self.consumer_group = self.redis_client.consumer_group( self.consumer_group, self.streams) self.consumer_group.create() # todo: investigate what this does! self.consumer_group.set_id(id="$")
def __init__(self, prefix, *args, **kwargs): super().__init__() self.prefix = prefix if self.config["cache"]["type"] != "redis": raise Exception( f"wrong cache type in config. expected 'redis', but got {self.config['cache']['type']}." ) connection_info = self.config["cache"]["params"] self.client = walrus.Database(**connection_info)
def __init__(self): #requests are read from redis and responses are returned in redis self.redisdb = walrus.Database(host=config['redis']['host'], port=config['redis']['port'], password=config['redis']['password'], db=config['redis']['db']) self.currentWork = self.redisdb.Hash('qwc:currentWork') self.waitingWork = self.redisdb.List('qwc:waitingWork') self.sessionKey = 'qwc:sessionTicket'
def check_connection(self): if isinstance(self.connection_info, str): self.connection_info = json.loads(self.connection_info) try: client = walrus.Database(**self.connection_info) client.dbsize() except Exception: return False else: return True
def __init__(self): self.logger = retrieve_logger("docker_monitor") self.docker_service = DockerService(self.logger) self.walrus = walrus.Database(host=GASS_REDIS_HOSTNAME, port=GASS_REDIS_PORT) self.docker_container_protocols = self.walrus.Hash(key=GASS_REDIS_DOCKET_CONTAINERS_PROTOCOLS_HASH_KEY) self.protocol_create = { "COAP": self.docker_service.start_coap_microservice, "MQTT": self.docker_service.start_mqtt_microservice, }
def connect(self, use_config=True, host=str(), port=0, password=str()): """ TDB """ if use_config: self._extract_redis_info() if self._cnx is None: self._cnx = wsredis.Database(host=self._host, port=self._port, db=0)
def to_redis_stream(self, topic, db=None, maxlen=None): """ push stream to redis stream ::topic:: redis stream topic ::db:: walrus redis databse object ,default :from walrus import Database,db=Database() """ import dill if not db: try: import walrus self.db = walrus.Database() except: raise producer = self.db.Stream(topic) from fn import F madd = F(producer.add, maxlen=maxlen) self.map(lambda x: { "data": dill.dumps(x) }).sink(madd) # producer only accept non-empty dict dict return self
def __init__(self, device_info, address, logger): super().__init__(daemon=True) self.device_info = self._transform_sen_ml_to_json(device_info) self.address = address self.logger = logger self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.devices_service = DevicesService(logger=self.logger) self.register_service = RegisterService(logger=self.logger) self.docker_service = DockerService(logger=self.logger) self.walrus = walrus.Database(host=GASS_REDIS_HOSTNAME, port=GASS_REDIS_PORT) self.containers_status = self.walrus.Hash( GASS_REDIS_DOCKET_CONTAINERS_PROTOCOLS_HASH_KEY) self.protocol_create = { "COAP": self._start_coap_microservice, "MQTT": self._start_mqtt_microservice, } self.protocol_check = { "COAP": self._verify_coap_microservice, "MQTT": self._verify_mqtt_microservices, }
killed_images = set() for container in self.docker_client.containers.list(): container.kill() killed_images.add(container.image) self.logger.info( "Killed container. Id: {}. Name: {}, Image: {}" .format(container.id, container.name, container.image) ) return killed_images def kill(self, id): self.docker_client.containers.get(id).kill() if __name__ == '__main__': import walrus walrus = walrus.Database(host=GASS_REDIS_HOSTNAME, port=GASS_REDIS_PORT) docker_container_protocol = walrus.Hash(key=GASS_REDIS_DOCKET_CONTAINERS_PROTOCOLS_HASH_KEY) docker_service = DockerService(FakeLogger()) # mqtt_container_id = docker_service.start_mqtt_microservice() # print(mqtt_container_id) # docker_container_protocol["MQTT"] = mqtt_container_id # docker_service.kill("ef2178a090be7d785680cf34bfc913c9ec397c9a185ac2403d962e9ba1f6ab39")
def _get_client(self): return walrus.Database(**self.connection_info)
def __init__(self, settings: OverhaveRedisSettings): self._settings = settings self._database = walrus.Database(host=settings.redis_url.host, port=settings.redis_url.port, db=settings.redis_db, retry_on_timeout=True)
def connect_redis(self): self.redis_db = walrus.Database(**self.options['redis']) self.redis_conn = redis.Redis(**self.options['redis']) BaseRedisKey.init(self) self.logger.info('Connecting mongo: %(host)s:%(port)s/%(db)s' \ % self.options['redis'])
class ChatConsumer(AsyncJsonWebsocketConsumer): db = walrus.Database() async def connect(self): self.user = self.scope["user"] self.workspace_slug = self.scope["url_route"]["kwargs"][ "workspace_slug"] self.room_slug = self.scope["url_route"]["kwargs"]["room_slug"] if self.user.is_anonymous: print("annonymous won") await self.close() if await database_sync_to_async(complex_user_acces_room)( self.user, self.workspace_slug, self.room_slug): await self.accept() await self.after_connect() else: await self.disconnect(code="no chyba nie") async def disconnect(self, code): user_status_workspace = self.db.Hash(GROUP_NAMES["user_status"]( self.workspace_slug)) del user_status_workspace[self.user.username] await self.channel_layer.group_send( GROUP_NAMES["user_status"](self.workspace_slug), { "type": "set.user.status", "username": self.user.username, "status": "offline", }) async def receive_json(self, text_data=None, bytes_data=None): command = text_data["command"] args = tuple(text_data["args"]) await self.new_message(*args) async def after_connect(self): user_status_workspace = self.db.Hash(GROUP_NAMES["user_status"]( self.workspace_slug)) user_status_workspace.update({self.user.username: "******"}) await self.send_json({ "command": "username", "args": [self.user.username] }) await self.channel_layer.group_add( GROUP_NAMES["user_status"](self.workspace_slug), self.channel_name) await self.channel_layer.group_add( GROUP_NAMES["messages"](self.workspace_slug, self.room_slug), self.channel_name) await self.channel_layer.group_send( GROUP_NAMES["user_status"](self.workspace_slug), { "type": "set.user.status", "username": self.user.username, "status": "active", }) await self.get_users_status() async def new_message(self, text): try: def f(text): workspace = Workspace.objects.get(slug=self.workspace_slug) room = workspace.room_set.get(slug=self.room_slug) message = Message(text=text, room=room, workspace=workspace, author=self.user) message.save() return message message = await database_sync_to_async(f)(text) await self.channel_layer.group_send( GROUP_NAMES["messages"](self.workspace_slug, self.room_slug), { "type": "broadcast.message", "username": self.user.username, "text": message.text, }) except Exception as e: print(e) async def broadcast_message(self, event): content = { "command": "new_message", "args": [event["username"], event["text"]] } await self.send_json(content) async def get_users_status(self): user_status_workspace = self.db.Hash(GROUP_NAMES["user_status"]( self.workspace_slug)) deserialized_dict = { key.decode(): val.decode() for key, val in user_status_workspace.items() } content = {"command": "get_users_status", "args": [deserialized_dict]} await self.send_json(content) async def set_user_status(self, event): content = { "command": "set_user_status", "args": [event["status"], event["username"]] } await self.send_json(content)
def __init__(self, stream, connection_info): if isinstance(connection_info, str): connection_info = json.loads(connection_info) self.client = walrus.Database(**connection_info) self.stream = self.client.Stream(stream)
def _get_client(self): return walrus.Database(host=self.host, port=self.port, db=self.db)
def _get_connection(self): return walrus.Database(host=self.host, port=self.port, db=self.db, socket_connect_timeout=10)
def _get_connection(self): return walrus.Database(**self.connection_params)
def get_redis_connection(): redis_url = config.get("REDIS_URL", "redis://127.0.0.1:6379/0") return walrus.Database().from_url(redis_url)
def start(self): self.client = walrus.Database().from_url(self.redis_uri, **self.options)