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)
