#!/usr/bin/env python

import os
import logging
from twisted.web import xmlrpc, server
from server.TDB import TreeDataBase
from lechat.Credential import Credential
import pickle
from twisted.internet import ssl
from twisted.python.util import sibpath
from optparse import OptionParser
import ConfigParser

class TDBRPC(xmlrpc.XMLRPC):
    """TreeDataBase XMLRPC server."""
    def __init__(self, config):
        xmlrpc.XMLRPC.__init__(self)
        self.db = TreeDataBase(config.ldap_server, config.base_dn)

    def xmlrpc_commit(self, args):
        """Commit changes to TDB."""
        _args = pickle.loads(args)
        cred = _args['cred']
        changes = _args['changes']
        c=[]
        try:
            self.db.commit(cred, changes)
        except Exception, error:
            return "Error on commit: %s" % error
        return ''

    def xmlrpc_getTree(self, args):
        """
        Returns tree rooted at base_path as a pickled DataTree.
        """
        _args = pickle.loads(args)
        cred = _args['cred']
        base_path = _args['base_path']
        _filter = _args['filter']
        try:
            result = self.db.getTree(cred, base_path, _filter)
        except:
            print "Error on getTree"
            result = None
        return pickle.dumps(result)


class ServerOption:
    def __init__(self, short, long, var, default, help):
        self.short = short
        self.long = long
        self.var = var
        self.default = default
        self.help = help

class Options(object):
    pass

server_options = [ 
    ServerOption("-l", "--ldap", "ldap_server", "ldap://localhost",
                 "ldap server URI"),
    ServerOption("-b", "--basedn", "base_dn", "dc=nodomain",
                 "set LDAP tree root at BASEDN"),
    ServerOption("-k", "--keyfile", "keyfile", "/etc/lechat/server.key",
                 "SSL private key file"),
    ServerOption("-c", "--certfile", "certfile", "/etc/lechat/server.pem",
                 "SSL certificate file"),
    ServerOption("-C", "--config", "conffile", "/etc/lechat/server.conf",
                 "Configuration file"),
    ]

def parse_commandline(config):
    parser = OptionParser()
    for o in server_options:
        parser.add_option(o.short, o.long, dest = o.var, default = o.default,
                          help = o.help)
    (options, args) = parser.parse_args()
    for k,v in options.__dict__.items():
        config.__setattr__(k,v)

def parse_configfile(config):
    parser = ConfigParser.ConfigParser()
    try:
        conffile = open(config.conffile)
    except:
        logging.warning("can't open configuration file %s" % config.conffile)
        return

    parser.readfp(conffile)

    items = {}
    for k,v in parser.items('DEFAULT'):
        if config.__dict__.has_key(k):
            items[k] = v
        else:
            logging.warning("unknown config variable %s" % k)

    for o in server_options:
        if items.has_key(o.var):
            config.__setattr__(o.var, items[o.var])

if __name__ == '__main__':
    logging.basicConfig(level=logging.DEBUG)

    from twisted.internet import reactor

    config = Options()

    parse_commandline(config)
    parse_configfile(config)

    #r = TDBRPC('ldapi://var%2frun%2fslapd%2fldapi',
    #           'dc=lechat,dc=praksys,dc=net')
    r = TDBRPC(config)

    # reactor.listenTCP(7080, server.Site(r))

    reactor.listenSSL(7080, server.Site(r),
                      contextFactory=ssl.DefaultOpenSSLContextFactory(
            config.keyfile,
            config.certfile,
            ) )
    
    reactor.run()