#! /usr/bin/env python3

import sys
import os
import traceback
import logging
import logging.handlers
import pprint
import subprocess
from multiprocessing import Pool, Value, Queue
import multiprocessing
import re

class Operation(object):
    
    def __init__(self):
        self.__logger = logging.getLogger()
    

    def worker(self, database):
        self.__logger.warning("worker process %s" % database)

    def startNoPool(self):
        workers = []
        for i in range(10):
            worker = multiprocessing.Process(target=self.worker,
                                             args=(i,))
            workers.append(worker)
            worker.start()
        for w in workers:
            w.join()

    def start(self):
        pool = Pool(processes=3)

        results = []
        for i in range(10):
            results.append(pool.apply_async(self.worker, (i,)))

        pool.close()
        pool.join()
        for result in results:
            result.get()


def initLogger():
    logger = logging.getLogger()
    sh = logging.StreamHandler( sys.__stdout__ )
    logger.addHandler(sh)

def listenerProcess(queue, configurer):
    configurer()
    while True:
        try:
            record = queue.get()
            if record is None:  
                break
            logger = logging.getLogger(record.name)
            logger.handle(record)  
        except Exception:
            import sys, traceback
            print('Whoops! Problem:', file=sys.stderr)
            traceback.print_exc(file=sys.stderr)


if __name__ == '__main__':
    queue = multiprocessing.Manager().Queue(-1)
    queue = multiprocessing.Queue(-1)
    listener = multiprocessing.Process(target=listenerProcess,
                                       args=(queue, initLogger))
    listener.start()
    
    try:
        logger = logging.getLogger()
        logger.addHandler(logging.handlers.QueueHandler(queue))
        logger.setLevel(logging.DEBUG)
        
        op = Operation()
        logger.info("starting (without multiprocessing pool)...")
        op.startNoPool()
        logger.info("starting (with multiprocessing pool)...")
        op.start()
    finally:
        queue.put_nowait(None)
        listener.join()