Clean up Redis logic

Simplify functions and move internal database interfaces into a more
appropriate data structure.

Signed-off-by: Georg Pfuetzenreuter <mail@georg-pfuetzenreuter.net>

plugin.py

@@ -29,14 +29,8 @@
 ###
 
 from supybot import (
-    utils,
-    plugins,
     ircutils,
     callbacks,
-    ircdb,
-    conf,
-    log,
-    world,
     ircmsgs,
 )
 from supybot.commands import *
@@ -51,15 +45,11 @@ except ImportError:
     _ = lambda x: x
 
 import re
-import os
-import sys
-import time
-import sqlite3
 import redis
 import json
 from datetime import timedelta
 from ipwhois import IPWhois
-import ipwhois
+from ipwhois.exceptions import IPDefinedError
 
 
 class SnoParser(callbacks.Plugin):
@@ -67,62 +57,38 @@ class SnoParser(callbacks.Plugin):
 
     threaded = True
 
-    def redis_connect_whois(self) -> redis.client.Redis:
+    def _redis_connect(self, db) -> redis.client.Redis:
         try:
-            redis_client_whois = redis.Redis(
+            redis_client = redis.Redis(
                 host=self.registryValue("redis.host"),
                 port=self.registryValue("redis.port"),
                 password=self.registryValue("redis.password"),
                 username=self.registryValue("redis.username"),
-                db=self.registryValue("whois.redis.db"),
+                db=self.registryValue(f"redis.db.{db}"),
                 socket_timeout=int(self.registryValue("redis.timeout")),
             )
-            ping = redis_client_whois.ping()
+            ping = redis_client.ping()
             if ping is True:
-                return redis_client_whois
-        except redis.AuthenticationError:
-            print("Could not authenticate to Redis backend.")
-
-    def redis_connect_nicks(self) -> redis.client.Redis:
-        try:
-            redis_client_nicks = redis.Redis(
-                host=self.registryValue("redis.host"),
-                port=self.registryValue("redis.port"),
-                password=self.registryValue("redis.password"),
-                username=self.registryValue("redis.username"),
-                db=self.registryValue("redis.db1"),
-                socket_timeout=int(self.registryValue("redis.timeout")),
-            )
-            ping = redis_client_nicks.ping()
-            if ping is True:
-                return redis_client_nicks
-        except redis.AuthenticationError:
-            print("Could not authenticate to Redis backend.")
-
-    def redis_connect_ips(self) -> redis.client.Redis:
-        try:
-            redis_client_ips = redis.Redis(
-                host=self.registryValue("redis.host"),
-                port=self.registryValue("redis.port"),
-                password=self.registryValue("redis.password"),
-                username=self.registryValue("redis.username"),
-                db=self.registryValue("redis.db2"),
-                socket_timeout=int(self.registryValue("redis.timeout")),
-            )
-            ping = redis_client_ips.ping()
-            if ping is True:
-                return redis_client_ips
+                return redis_client
         except redis.AuthenticationError:
             print("Could not authenticate to Redis backend.")
 
     def __init__(self, irc):
         super().__init__(irc)
-        self.redis_client_whois = self.redis_connect_whois()
-        self.redis_client_nicks = self.redis_connect_nicks()
-        self.redis_client_ips = self.redis_connect_ips()
+        self.redis_clients = {
+            'ips': self._redis_connect("ips"),
+            'nicks': self._redis_connect("nicks"),
+            'whois': self._redis_connect("whois"),
+        }
+
+    def _get_from_cache(self, db, key):
+        """ Get value from Redis cache """
+
+        return self.redis_clients[db].get(key)
 
     def whois_fresh(self, sourceip: str) -> dict:
         """Data from WHOIS backend (IANA or respective RIR)."""
+
         asn = 0
         subnet = ""
         try:
@@ -135,37 +101,25 @@ class SnoParser(callbacks.Plugin):
             country = whoisres["asn_country_code"]
             description = whoisres["asn_description"]
             whoisout = asn + " " + country + " " + description
-        except ipwhois.exceptions.IPDefinedError:
+        except IPDefinedError:
             whoisout = "RFC 4291 (Local)"
 
         response = whoisout
         return response
 
-    def whois_get_cache(self, key: str) -> str:
-        """Data from Redis."""
-
-        k = self.redis_client_whois.get(key)
-
-        #        self = SnoParser()
-        #        val = self.redis_client_whois.get(key)
-        val = k
-        return val
-
     def whois_set_cache(self, key: str, value: str) -> bool:
         """Data to Redis."""
 
-        duration = int(self.registryValue("whois.ttl"))
-        state = self.redis_client_whois.setex(
+        return self.redis_clients['whois'].setex(
             key,
-            timedelta(seconds=duration),
+            timedelta(seconds=int(self.registryValue("whois.ttl"))),
             value=value,
         )
-        return state
 
     def whois_run(self, sourceip: str) -> dict:
         """Whois query router."""
 
-        data = self.whois_get_cache(key=sourceip)
+        data = self._get_from_cache("whois", sourceip)
         if data is not None:
             data = json.loads(data)
             if self.registryValue("whois.debug"):
@@ -201,14 +155,14 @@ class SnoParser(callbacks.Plugin):
     def nick_run(self, nickname: str) -> dict:
         """Tracks nicknames"""
 
-        data = self.redis_client_nicks.get(nickname)
+        data = self._get_from_cache("nicks", nickname)
 
         if data is not None:
             if self.registryValue("debug"):
                 print("SNOPARSER DEBUG - NICK_RUN, SEEN: TRUE")
                 print(nickname)
                 print(data)
-            self.redis_client_nicks.incrby(nickname, amount=1)
+            self.redis_clients['nicks'].incrby(nickname, amount=1)
             if data:
                 decoded = data.decode("utf-8")
                 return decoded
@@ -219,7 +173,7 @@ class SnoParser(callbacks.Plugin):
                 print("SNOPARSER DEBUG _ NICK_RUN, SEEN: FALSE")
                 print(nickname)
                 print(data)
-            self.redis_client_nicks.set(nickname, value="1")
+            self.redis_clients['nicks'].set(nickname, value="1")
             if data:
                 decoded = data.decode("utf-8")
                 return decoded
@@ -229,14 +183,13 @@ class SnoParser(callbacks.Plugin):
     def ip_run(self, ipaddress: str) -> dict:
         """Tracks IP addresses"""
 
-        data = self.redis_client_ips.get(ipaddress)
-
+        data = self._get_from_cache("ips", ipaddresses)
         if data is not None:
             if self.registryValue("debug"):
                 print("SNOPARSER DEBUG - IP_RUN, SEEN: TRUE")
                 print(ipaddress)
                 print(data)
-            self.redis_client_ips.incrby(ipaddress, amount=1)
+            self.redis_clients['ips'].incrby(ipaddress, amount=1)
             if data:
                 decoded = data.decode("utf-8")
                 return decoded
@@ -247,7 +200,7 @@ class SnoParser(callbacks.Plugin):
                 print("SNOPARSER DEBUG _ IP_RUN, SEEN: FALSE")
                 print(ipaddress)
                 print(data)
-            self.redis_client_ips.set(ipaddress, value="1")
+            self.redis_clients['ips'].set(ipaddress, value="1")
             if data:
                 decoded = data.decode("utf-8")
                 return decoded
@@ -259,10 +212,10 @@ class SnoParser(callbacks.Plugin):
         Queries the cache for an address.
         """
 
-        data = self.whois_get_cache(key=ipaddress)
+        data = self.redis_clients['whois'].get(sourceip)
         decoded_data = data.decode("utf-8")
-        ttl = self.redis_client_whois.ttl(ipaddress)
-        count = self.redis_client_ips.get(ipaddress)
+        ttl = self.redis_clients['whois'].ttl(ipaddress)
+        count = self.redis_clients['ips'].get(ipaddress)
         decoded_count = count.decode("utf-8")
         print("SnoParser manual query: ", data, " ", ttl)
         irc.reply(f"{decoded_data} - Count: {decoded_count} - Remaining: {ttl}s")