#!/usr/bin/env python3.1

# This script converts SquidGuard database into format that can be imported to
# squid-tagger. It should be run in SquidGuard database directory and it would
# produce csv stream that can be redirected to squid-tagger for imports:

# cd /var/db/squidGuard ; path/to/sg_import.py | path/to/squid-tagger.py -l -f

class Config:
	__slots__ = frozenset(['_config', '_default', '_section', 'options'])
	_default = {
		'log': {
			'silent': 'no',
		},
		'database': {
			'host': 'localhost',
			'database': 'squidTag',
	},}

	# function to read in config file
	def __init__(self):
		import ConfigParser, optparse, os

config = Config()

import logging, logging.handlers

# wrapper around logging handler to make it queue records and don't stall when sending them

class SysLogHandlerQueue(logging.handlers.SysLogHandler):
	__slots__ = frozenset(['_event', '_tail', '_workers'])

	def __init__(self):
		logging.handlers.SysLogHandler.__init__(self, '/dev/log')
		self._event = gevent.event.Event()
		self._event.set()
		self._tail = gevent.queue.Queue()
		self._workers = set()

	def emit(self, record):
		# my syslog is broken and cannot into UTF-8 BOM
		record.msg = str(record.msg)
		self._tail.put(record)
		if self._tail.qsize() != 0:
			# in case queue is empty we will spawn new worker
			# all workers are logged so we can kill them on close()
			self._workers.add(gevent.spawn(self._writer))

	def _writer(self):
		# here we are locking the queue so we can be sure we are the only one
		self._event.wait()
		self._event.clear()
		while not self._tail.empty():
			logging.handlers.SysLogHandler.emit(self, self._tail.get())
		self._event.set()
		self._workers.remove(gevent.getcurrent())


	def close(self):
		for worker in self._workers:
			gevent.kill(worker)
		logging.handlers.SysLogHandler.close(self)

logger = logging.getLogger('squidTag')
logger.setLevel(logging.INFO)
handler = SysLogHandlerQueue()
handler.setFormatter(logging.Formatter(str('squidTag[%(process)s]: %(message)s')))
logger.addHandler(handler)

# tiny wrapper around a file to make reads from it geventable
# or should i move this somewhere?

class FReadlineQueue(gevent.queue.Queue):
	# storing file descriptor, leftover
	__slots__ = frozenset(['_fd', '_tail'])

	def __init__(self, fd):

		# initialising class
		gevent.queue.Queue.__init__(self)
		# storing file descriptor
		self._fd = fd

		# using empty tail
		self._tail = ''
		# setting up event
		self._install_wait()

	def _install_wait(self):
		fileno = self._fd.fileno()
		# putting file to nonblocking mode
		fcntl.fcntl(fileno, fcntl.F_SETFL, fcntl.fcntl(fileno, fcntl.F_GETFL)  | os.O_NONBLOCK)
		# installing event handler
		gevent.core.read_event(fileno, self._wait_helper)

	def _wait_helper(self, ev, evtype):
		# reading one buffer from stream
		buf = self._fd.read(4096)
		# splitting stream by line ends
		rows = buf.decode('l1').split('\n')
		# adding tail to the first element if there is some tail
		if len(self._tail) > 0:
			rows[0] = self._tail + rows[0]
		# popping out last (incomplete) element
		self._tail = rows.pop(-1)
		# dropping all complete elements to the queue
		for row in rows:
			self.put_nowait(row)
			logger.info('< ' + row)
		if len(buf) > 0:
			# no EOF, reinstalling event handler
			gevent.core.read_event(self._fd.fileno(), self._wait_helper)
		else:
			# EOF found, sending EOF to queue
			self.put_nowait(None)

stdin = FReadlineQueue(sys.stdin)

# wrapper against file handler that makes possible to queue some writes without stalling

class FWritelineQueue(gevent.queue.JoinableQueue):
	# storing fileno, io interface, leftover
	__slots__ = frozenset(['_fileno', '_io', '_tail'])