try async non-blocking timers instead of the timer thread used in flowalerts

[AlyaGomaa]

See if this works

import asyncio

async def check_connection_without_dns_resolution(self, profileid, twid, flow):

        # Start a non-blocking timer
        await asyncio.sleep(15)

        # After 15 seconds, recheck the DNS resolution
        if self.check_if_resolution_was_made_by_different_version(profileid, flow.daddr):
            return False

        if self.is_well_known_org(flow.daddr):
            return False

        self.set_evidence.conn_without_dns(twid, flow)

        # This UID will never appear again, so we can remove it and free memory
        with contextlib.suppress(ValueError):
            self.connections_checked_in_conn_dns_timer_thread.remove(flow.uid)

the goal is to avoid starting threads as much as possible to avoid hanging threads/processes in memory

[AlyaGomaa]

same goes with all the usage of timerthread in ssh.py and dns.py

[AlyaGomaa]

Here's a plan of how this async hell is going to be implemented

• My goal was to not make main() or controller() async and to be able to finish all scheduled tasks before exiting (which is what i did in shutdown_gracefully()
• IModule will be handling async shutdown gracefully functions different than normal shutdown gracefully() functions to ensure that both finish executing before a module stops

  
  import asyncio
  import warnings, time

warnings.filterwarnings("ignore", category=RuntimeWarning)

class X: def init(self): self.tasks = []

async def check_dns(self):
    """any function that waits for anything will look lik ethis"""
    print("Fetching data...")
    await asyncio.sleep(2)  
    print("Data fetched!")

async def analyze(self):
    """Analyze of any flowanalyzer in flowalerts, like dns.py ssh.py etc"""
    print("analyze just started")
    time.sleep(3)
    t = asyncio.create_task(self.check_dns())
    self.tasks.append(t) 
    print("Analyze just ended")

async def shutdown_gracefully(self):
    await asyncio.gather(*self.tasks)
    print("shutdown gracefully is done")

def main(self):
    """main of flowalerts supposedly"""
    loop = asyncio.get_event_loop()
    loop.create_task(self.analyze())  
    print("flowalerts main is done execution")

def controller(self):
    """will be IModule's run """
    loop = asyncio.get_event_loop()
    self.main()  # Schedule tasks
    loop.run_until_complete(self.shutdown_gracefully())  

X().controller()

[AlyaGomaa]

done here #1012