Merge lp:~unifield-team/unifield-toolbox/invalid-name-instance into lp:unifield-toolbox

[Quentin THEURET @Amaris]

Unmerged revisions

17. By Quentin THEURET @Amaris on 2011-10-26

Test if the name of the instance contains an invalid character and stop the program if yes

16. By Duy Vo <dvo@uf0002> on 2011-10-24

Add runbot

15. By Duy Vo <dvo@uf0002> on 2011-10-24

Resolve conflict

14. By jf <jf@tempo4> on 2011-10-07

[IMP] option skell --unit to run unit test

13. By jf <jf@tempo4> on 2011-08-22

[IMP] Create and start a new inst. with 1 line

12. By jf <jf@tempo4> on 2011-08-21

[IMP] disabled in list

11. By jf <jf@tempo4> on 2011-08-21

[IMP] comment on index page

10. By jf <jf@tempo4> on 2011-08-21

[FIX] nginx path

9. By jf <jf@tempo4> on 2011-08-21

[IMP] change default runbot port

8. By jf <jf@tempo4> on 2011-08-21

[FIX] ignore . directory

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2011-10-26 10:12:24 +0000
@@ -0,0 +1,18 @@
+running/*
+common/unifield-wm
+common/unifield-web
+common/unifield-addons
+common/unifield-server
+common/unifield-data
+nginx/nginx.pid
+out.log
+nginx/access.log
+nginx/error.log
+nginx/index.html
+!nginx/ok.png
+!nginx/nok.png
+nginx/*.png
+nginx/nginx.conf
+nginx/nginx.conf
+common/.bzr
+running/.bzr

=== added directory 'common'
=== added directory 'common/etc'
=== added file 'common/etc/default_config.ini'
--- common/etc/default_config.ini	1970-01-01 00:00:00 +0000
+++ common/etc/default_config.ini	2011-10-26 10:12:24 +0000
@@ -0,0 +1,27 @@
+[global]
+; set port to 0 to automatically get a free port
+; change it at your own risk
+port = 0
+
+; comma separated list of modules to load
+modules = msf_profile
+
+; if true: load the csv data from unifield-data (only available if msf_profile is loaded)
+load_data = 1
+; if load_data, you can set an email address
+email =
+
+; load openerp demo xml (disabled if load_data is true)
+load_demo = 0
+
+; comment added on web page
+comment =
+
+; launchpad branches i.e: lp:unifield-wm/main
+; if set to 'link', a soft link will be created from common/ directory
+; if the directory already exists in "running/" nothing will be done
+unifield-wm = link
+unifield-addons = link
+unifield-web = link
+unifield-server = link
+unifield-data = link

=== added file 'common/etc/openerprc'
--- common/etc/openerprc	1970-01-01 00:00:00 +0000
+++ common/etc/openerprc	2011-10-26 10:12:24 +0000
@@ -0,0 +1,57 @@
+[options]
+without_demo = all
+smtp_port = 25
+xmlrpcs_interface = 
+syslog = False
+logrotate = True
+xmlrpcs_port = 
+test_report_directory = False
+list_db = True
+timezone = False
+xmlrpc_interface = 
+test_file = False
+cache_timeout = 100000
+smtp_password = False
+secure_pkey_file = server.pkey
+xmlrpc_port = 
+log_level = info
+xmlrpc = True
+test_disable = False
+admin_passwd = 4unifield
+assert_exit_level = error
+smtp_server = localhost
+static_http_url_prefix = None
+test_commit = False
+xmlrpcs = False
+demo = {}
+login_message = False
+import_partial = 
+pidfile = PIDFILE
+db_maxconn = 64
+stop_after_init = False
+osv_memory_count_limit = False
+reportgz = False
+osv_memory_age_limit = 1.0
+netrpc_port = 
+db_port = False
+db_name = UF_INSTANCE
+debug_mode = False
+netrpc = True
+secure_cert_file = server.cert
+logfile = 
+csv_internal_sep = ,
+pg_path = None
+static_http_enable = False
+translate_modules = ['all']
+smtp_ssl = False
+root_path = 
+netrpc_interface = 
+smtp_user = False
+
+db_user=
+db_password=
+db_host=
+
+email_from = False
+addons_path = UF_ADDONS_PATH/unifield-addons,UF_ADDONS_PATH/unifield-wm
+static_http_document_root = None

=== added file 'kill.sh'
--- kill.sh	1970-01-01 00:00:00 +0000
+++ kill.sh	2011-10-26 10:12:24 +0000
@@ -0,0 +1,8 @@
+#! /bin/bash
+
+RUNNING_PATH=$1
+
+if [ -z "$RUNNING_PATH" ]; then
+    RUNNING_PATH=/running
+fi
+kill `ps aux | grep $RUNNING_PATH  | awk '{print $2}'`

=== added directory 'lib'
=== added file 'lib/__init__.py'
--- lib/__init__.py	1970-01-01 00:00:00 +0000
+++ lib/__init__.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,1 @@
+import initdb

=== added file 'lib/initdb.py'
--- lib/initdb.py	1970-01-01 00:00:00 +0000
+++ lib/initdb.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,89 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+
+import optparse
+import os
+import getpass
+import sys
+import glob
+import re
+import base64
+import time
+import utils
+import socket
+
+def nb_request():
+    return len(utils.rpc.RPCProxy('res.request').search([('act_to', 'in', [utils.rpc.session.uid])]))
+
+def import_csv(lpath):
+    for f in sorted(glob.glob(os.path.join(lpath, '*.csv'))): 
+        nbr = nb_request()
+        m = re.match('.*/\d+_(.*)\.csv', f)
+        if not m:
+            continue
+        obj = m.group(1)
+        
+        fo = open(f)
+        wid = utils.rpc.RPCProxy('import_data').create({'ignore': 1, 'object': obj, 'file': base64.encodestring(fo.read()), 'debug': True})
+        fo.close()
+        utils.rpc.RPCProxy('import_data').import_csv([wid])
+        while nb_request() == nbr:
+            time.sleep(5)
+
+def wizard_init():
+    wiz = utils.rpc.RPCProxy('res.config').start([])
+    while wiz and wiz.get('res_model') not in ('base.setup.config','ir.ui.menu'):
+        id = utils.rpc.RPCProxy(wiz['res_model']).create({})
+        wiz = utils.rpc.RPCProxy(wiz['res_model']).action_next([id])
+    if wiz.get('res_model') == 'base.setup.config':
+        utils.rpc.RPCProxy(wiz['res_model']).config([])
+        return True
+    return False
+
+def try_socket(sock, host, port, max_wait, start_time=False):
+    if not start_time:
+        start_time = time.time()
+    try:
+        sock.connect((host, int(port)))
+    except socket.error, e:
+        if e.errno == 111:
+            if time.time()-start_time > max_wait:
+                return False
+        time.sleep(5)
+        return try_socket(sock, host, port, max_wait, start_time)
+    sock.close()
+    return True
+
+def connect_db(user, pwd, dbname, host, port, path):
+    msg = []
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    if try_socket(sock, host, port, 290):
+        utils.rpc.initialize(host, port, 'socket', storage=dict())
+        utils.rpc.session.login(dbname, user, pwd)
+        wiz = wizard_init()
+        if wiz:
+            import_csv(path)
+            return 'Data successfully loaded'
+        return 'Data not loaded: no init wizard to execute' 
+    
+    raise Exception('Data not loaded: server is not ready')
+
+
+if __name__=="__main__":
+    usage = "usage: %prog [options] import_dir"
+    parser = optparse.OptionParser(usage=usage)
+    parser.add_option("-d", "--database", dest="dbname", help="Database [default: %default]",default="test")
+    parser.add_option("-H", "--host", dest="host", help="Host [default: %default]",default="127.0.0.1")
+    parser.add_option("-p", "--port", dest="port", help=u"Port [default: %default]",default="8070")
+    parser.add_option("-u", "--user", dest="user", help="User [default: %default]", default="admin")
+    parser.add_option("-w", "--password", dest="pwd", help="Password")
+    (opt, args) = parser.parse_args()
+
+    if len(args) < 1:
+        parser.error("Missing arg import_dir")
+
+    if not opt.pwd:
+        opt.pwd = getpass.getpass('Password : ')
+
+    connect_db(opt.user, opt.pwd, opt.dbname, opt.host, opt.port, args[0])

=== added directory 'lib/utils'
=== added file 'lib/utils/__init__.py'
--- lib/utils/__init__.py	1970-01-01 00:00:00 +0000
+++ lib/utils/__init__.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,1 @@
+import rpc

=== added file 'lib/utils/errors.py'
--- lib/utils/errors.py	1970-01-01 00:00:00 +0000
+++ lib/utils/errors.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+__all__ = ['AuthenticationError', 'TinyException', 'TinyError',
+           'TinyWarning', 'TinyMessage', 'Concurrency', 'AccessDenied']
+
+class AuthenticationError(Exception): pass
+
+
+class TinyException(Exception):
+
+    def __init__(self, message, title=None):
+
+        self.title = title
+        self.message = message
+
+    def __unicode__(self):
+        return ustr(self.message)
+
+    def __str__(self):
+        return self.message
+
+class TinyError(TinyException):
+
+    def __init__(self, message, title=None):
+        if title is None: title = "Error"
+        TinyException.__init__(self, message=message, title=title)
+
+class TinyWarning(TinyException):
+
+    def __init__(self, message, title=None):
+        if title is None: title = "Warning"
+        TinyException.__init__(self, message=message, title=title)
+
+class TinyMessage(TinyException):
+
+    def __init__(self, message, title=None):
+        if title is None: title = "Information"
+        TinyException.__init__(self, message=message, title=title)
+
+class Concurrency(Exception):
+
+    def __init__(self, message, title=None, datas=None):
+        self.title = title
+        self.datas = datas
+        self.message = message
+
+    def __unicode__(self):
+        return ustr(self.title)
+
+    def __str__(self):
+        return self.title
+
+class AccessDenied(TinyError): pass
+
+def error(title, msg):
+    raise TinyError(message=msg, title=title or "Error")
+
+def warning(msg, title=None):
+    raise TinyWarning(message=msg, title=title or "Warning")
+
+def message(msg):
+    raise TinyMessage(message=msg)
+
+def concurrency(msg, title=None, datas=None):
+    raise Concurrency(message=msg, title=title, datas=datas)
+

=== added file 'lib/utils/rpc.py'
--- lib/utils/rpc.py	1970-01-01 00:00:00 +0000
+++ lib/utils/rpc.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,460 @@
+###############################################################################
+#
+#  Copyright (C) 2007-TODAY OpenERP SA. All Rights Reserved.
+#
+#  $Id$
+#
+#  Developed by OpenERP (http://openerp.com) and Axelor (http://axelor.com).
+#
+#  The OpenERP web client is distributed under the "OpenERP Public License".
+#  It's based on Mozilla Public License Version (MPL) 1.1 with following 
+#  restrictions:
+#
+#  -   All names, links and logos of OpenERP must be kept as in original
+#      distribution without any changes in all software screens, especially
+#      in start-up page and the software header, even if the application
+#      source code has been changed or updated or code has been added.
+#
+#  You can see the MPL licence at: http://www.mozilla.org/MPL/MPL-1.1.html
+#
+###############################################################################
+
+import socket
+import xmlrpclib
+
+import errors
+
+from tiny_socket import TinySocket
+from tiny_socket import TinySocketError
+
+class NotLoggedIn(errors.TinyError, errors.AuthenticationError): pass
+
+class RPCException(Exception):
+    """A common exeption class for RPC errors.
+    """
+
+    def __init__(self, code, backtrace):
+
+        self.code = code
+        self.args = backtrace
+
+        if hasattr(code, 'split'):
+            lines = code.split('\n')
+
+            self.type = lines[0].split(' -- ')[0]
+            self.message = ''
+            if len(lines[0].split(' -- ')) > 1:
+                self.message = lines[0].split(' -- ')[1]
+
+            self.data = '\n'.join(lines[2:])
+
+        else:
+            self.type = 'error'
+            self.message = backtrace
+            self.data = backtrace
+
+        self.backtrace = backtrace
+
+    def __str__(self):
+        return self.message
+
+
+class RPCGateway(object):
+    """Gateway abstraction, that implement common stuffs for rpc gateways.
+    All RPC gateway should extends this class.
+    """
+
+    def __init__(self, session):
+        if not isinstance(session, RPCSession):
+            raise TypeError("RPCSession argument expected, got %s" % type(session))
+        self.session = session
+
+    def __rpc__(self, obj, method, args=(), auth=True):
+        """Derived classes should owverride this method.
+
+        @param obj: the remote object
+        @param method: the method of the remote object
+        @param args: arguments to be passed
+        @param oauth: authentication is required or not
+
+        @return: the result of the method
+        """
+        pass
+
+    @property
+    def connection_string(self):
+        """Get the connection string...
+        """
+        return "%s://%s:%s/"%(self.session.protocol, self.session.host, self.session.port)
+
+    def __convert(self, result):
+
+        if isinstance(result, str):
+            # try to convert into unicode string
+            try:
+                return ustr(result)
+            except Exception, e:
+                return result
+
+        elif isinstance(result, list):
+            return [self.__convert(val) for val in result]
+
+        elif isinstance(result, tuple):
+            return tuple([self.__convert(val) for val in result])
+
+        elif isinstance(result, dict):
+            newres = {}
+            for key, val in result.items():
+                newres[key] = self.__convert(val)
+
+            return newres
+
+        else:
+            return result
+
+    def __execute(self, obj, method, args=(), auth=True):
+        try:
+            result = self.__rpc__(obj, method, args, auth=auth)
+            return self.__convert(result)
+        except socket.error, e:
+            raise errors.TinyException(e.message or e.strerror, title='Application Error')
+
+        except RPCException, err:
+            if err.type in ('warning', 'UserError'):
+                if err.message in ('ConcurrencyException') and len(args) > 4:
+                    errors.concurrency(err.message, err.data, args)
+                else:
+                    errors.warning(err.data)
+            else:
+                errors.error('Application Error', err.backtrace)
+
+        except Exception, e:
+            errors.error('Application Error', str(e))
+
+    def execute(self, obj, method, *args):
+        """Excecute the method of the obj with the given arguments.
+
+        @param obj: the remote object
+        @param method: the method of the remote object
+        @param args: arguments to be passed
+
+        @return: the result of the method
+        """
+        return self.__execute(obj, method, args)
+
+    def execute_noauth(self, obj, method, *args):
+        """Excecute the method of the obj with the given arguments without authentication.
+
+        @param obj: the object
+        @param method: the method to execute
+        @param args: the arguments
+
+        @return: the result of the method
+        """
+        return self.__execute(obj, method, args, auth=False)
+
+
+class XMLRPCGateway(RPCGateway):
+    """XMLRPC implementation.
+    """
+
+    def __init__(self, session):
+        """Create new instance of XMLRPCGateway.
+
+        @param session: a session
+        """
+        super(XMLRPCGateway, self).__init__(session)
+        self._url = self.connection_string + 'xmlrpc/'
+
+    def __rpc__(self, obj, method, args=(), auth=True):
+        sock = xmlrpclib.ServerProxy(self._url + str(obj))
+        try:
+            if auth:
+                args = (self.session.db, self.session.uid, self.session.password) + args
+            return getattr(sock, method)(*args)
+        except xmlrpclib.Fault, err:
+            raise RPCException(err.faultCode, err.faultString)
+
+
+class NETRPCGateway(RPCGateway):
+    """NETRPC Implementation.
+    """
+
+    def __rpc__(self, obj, method, args=(), auth=True):
+        sock = TinySocket()
+        try:
+            sock.connect(self.session.host, self.session.port)
+            if auth:
+                args = (self.session.db, self.session.uid, self.session.password) + args
+            sock.send((obj, method) + args)
+            res = sock.receive()
+            sock.disconnect()
+            return res
+
+        except xmlrpclib.Fault, err:
+            raise RPCException(err.faultCode, err.faultString)
+
+        except TinySocketError, err:
+            raise RPCException(err.faultCode, err.faultString)
+
+
+# XXX: Fix openobject server to return PyTZ compatible timezone name
+_TZ_ALIASES = {
+    'IST' : 'Asia/Calcutta'
+}
+
+
+class RPCSession(object):
+    """Maintains client session and provides way to authenticate
+    client & invoce RPC requested by clients.
+    """
+
+    __slots__ = ['host', 'port', 'protocol', 'storage', 'gateway']
+
+    def __init__(self, host, port, protocol='socket', storage={}):
+        """Create new instance of RPCSession.
+
+        @param host: the openobject-server host
+        @params port: the openobject-server port
+        @params protocol: the openobject-server protocol
+        @param storage: a dict like storage that will be used to store session data
+        """
+        self.host = host
+        self.port = port
+        self.protocol = protocol
+        self.storage = storage
+
+        if protocol in ('http', 'https'):
+            self.gateway = XMLRPCGateway(self)
+
+        elif protocol == 'socket':
+            self.gateway = NETRPCGateway(self)
+
+        else:
+            raise errors.message("Unsupported protocol.")
+
+    def __getattr__(self, name):
+        try:
+            return super(RPCSession, self).__getattribute__(name)
+        except:
+            pass
+
+        return self.storage.get(name)
+
+    def __setattr__(self, name, value):
+        if name in self.__slots__:
+            super(RPCSession, self).__setattr__(name, value)
+        else:
+            self.storage[name] = value
+
+    def __getitem__(self, name):
+        return self.storage[name]
+
+    def __setitem__(self, name, value):
+        self.storage[name] = value
+
+    def __delitem__(self, name):
+        try:
+            del self.storage[name]
+        except:
+            pass
+
+    def get(self, name, default=None):
+        return self.storage.get(name, default)
+
+    @property
+    def context(self):
+        return (self._context or {}).copy()
+
+    @property
+    def connection_string(self):
+        return self.gateway.connection_string
+
+    def listdb(self):
+        try:
+            return self.execute_noauth('db', 'list')
+        except errors.TinyError, e:
+            if e.message == 'AccessDenied':
+                return None
+            raise
+
+    def login(self, db, user, password):
+
+        if not (db and user and password):
+            return -1
+
+        try:
+            uid = self.execute_noauth('common', 'login', db, user, password)
+        except Exception, e:
+            return -1
+
+        if uid <= 0:
+            return -1
+
+        self._logged_as(db, uid, password)
+        return uid
+
+    def _logged_as(self, db, uid, password):
+        self.storage['uid'] = uid
+        self.storage['db'] = db
+        self.storage['password'] = password
+        self.storage['open'] = True
+
+        # read the full name of the user
+        res_users = self.execute('object', 'execute', 'res.users', 'read', [uid], ['name', 'company_id', 'login'])[0]
+        self.storage['user_name'] = res_users['name']
+        self.storage['company_id'], self.storage['company_name'] = res_users['company_id']
+        self.storage['loginname'] = res_users['login']
+        # set the context
+        self.context_reload()
+
+    def logout(self):
+        try:
+            self.storage.clear()
+        except Exception, e:
+            pass
+
+    def is_logged(self):
+        return self.uid and self.open
+
+    def context_reload(self):
+        """Reload the context for the current user
+        """
+
+        self.storage['_context'] = {'client': 'web'}
+
+        # self.uid
+        context = self.execute('object', 'execute', 'res.users', 'context_get')
+        self._context.update(context or {})
+
+        self.storage['remote_timezone'] = 'utc'
+        self.storage['client_timezone'] = self.context.get("tz", False)
+
+        if self.storage.get('client_timezone'):
+            self.storage['remote_timezone'] = self.execute('common', 'timezone_get')
+            try:
+                import pytz
+            except:
+                raise errors.warning('You select a timezone but OpenERP could not find pytz library!\nThe timezone functionality will be disable.')
+
+        # set locale in session
+        self.storage['locale'] = self.context.get('lang', 'en_US')
+        lang_ids = self.execute(
+                'object', 'execute', 'res.lang',
+                'search', [('code', '=', self.storage['locale'])])
+        if lang_ids:
+            self.storage['lang'] = self.execute(
+                    'object', 'execute', 'res.lang', 'read', lang_ids[0], [])
+
+    def execute(self, obj, method, *args):
+        if not self.is_logged():
+            raise NotLoggedIn('Not logged...', 'Authorization Error')
+
+        return self.gateway.execute(obj, method, *args)
+
+    def execute_noauth(self, obj, method, *args):
+        return self.gateway.execute_noauth(obj, method, *args)
+
+    def execute_db(self, method, *args):
+        return self.execute_noauth('db', method, *args)
+
+
+# global session variable, will be initialized with connect
+session = None
+
+
+def initialize(host, port, protocol='socket', storage=None):
+    """ Initialize the default rpc session.
+    """
+    global session
+    session = RPCSession(host, port, protocol, storage=storage)
+
+
+class RPCProxy(object):
+    """A wrapper arround xmlrpclib, provides pythonic way to access tiny resources.
+
+    For example,
+
+    >>> users = RPCProxy("ir.users")
+    >>> res = users.read([1], ['name', 'active_id'], session.context)
+    """
+
+    def __init__(self, resource):
+        """Create new instance of RPCProxy for the give tiny resource
+
+        @param resource: the tinyresource
+        """
+        self._resource = resource
+        self._session = session
+        self._attrs = {}
+
+    def _func_getter(self, name):
+        return lambda *args: self(name, *args)
+
+    def __getattr__(self, name):
+        if name not in self._attrs:
+            return self._attrs.setdefault(name, self._func_getter(name))
+        return self._attrs[name]
+
+    def __call__(self, *args):
+        return self._session.execute('object', 'execute',
+                                     self._resource, *args)
+
+    def fields_get(self, fields, context=None):
+        if context is None:
+            context = self._session.context
+        return self('fields_get', fields, context)
+    def fields_view_get(self, view_id, view_type, context=None,
+                        hastoolbar=False, hassubmenu=False):
+        if context is None:
+            context = self._session.context
+        return self('fields_view_get', view_id or False, view_type, context,
+                    hastoolbar, hassubmenu)
+
+    def search(self, criteria, offset=0, limit=False, order=False, context=None):
+        if context is None:
+            context = self._session.context
+        return self('search', criteria, offset, limit, order, context)
+
+def name_get(model, id, context=None):
+
+    id = (id or False) and int(id)
+    name = (id or str('')) and str(id)
+
+    if model and id:
+
+        ctx = session.context.copy()
+        ctx.update(context or {})
+
+        proxy = RPCProxy(model)
+
+        try:
+            name = proxy.name_get([id], ctx)
+            name = name and name[0][1] or ''
+        except errors.TinyWarning:
+            name = _("== Access Denied ==")
+
+    return name
+
+
+if __name__=="__main__":
+
+    host = 'localhost'
+    port = 8070
+    protocol = 'socket'
+
+    initialize(host, port, protocol, storage=dict())
+
+    res = session.listdb()
+    print res
+
+    res = session.login('t1', 'admin', 'admin')
+    print res
+
+    res = RPCProxy('res.users').read([session.uid], ['name'])
+    print res
+
+    print session.context
+
+
+# vim: ts=4 sts=4 sw=4 si et

=== added file 'lib/utils/tiny_socket.py'
--- lib/utils/tiny_socket.py	1970-01-01 00:00:00 +0000
+++ lib/utils/tiny_socket.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,92 @@
+###############################################################################
+#
+#  Copyright (C) 2007-TODAY OpenERP SA. All Rights Reserved.
+#
+#  $Id$
+#
+#  Developed by OpenERP (http://openerp.com) and Axelor (http://axelor.com).
+#
+#  The OpenERP web client is distributed under the "OpenERP Public License".
+#  It's based on Mozilla Public License Version (MPL) 1.1 with following 
+#  restrictions:
+#
+#  -   All names, links and logos of OpenERP must be kept as in original
+#      distribution without any changes in all software screens, especially
+#      in start-up page and the software header, even if the application
+#      source code has been changed or updated or code has been added.
+#
+#  You can see the MPL licence at: http://www.mozilla.org/MPL/MPL-1.1.html
+#
+###############################################################################
+
+import socket
+import cPickle
+import sys
+
+DNS_CACHE = {}
+
+class TinySocketError(Exception):
+
+    def __init__(self, faultCode, faultString):
+        self.faultCode = faultCode
+        self.faultString = faultString
+        self.args = (faultCode, faultString)
+
+SOCKET_TIMEOUT = 450
+socket.setdefaulttimeout(SOCKET_TIMEOUT)
+class TinySocket(object):
+
+    def __init__(self, sock=None):
+        if sock is None:
+            self.sock = socket.socket(
+            socket.AF_INET, socket.SOCK_STREAM)
+        else:
+            self.sock = sock
+        self.sock.settimeout(SOCKET_TIMEOUT)
+        # disables Nagle algorithm (avoids 200ms default delay on Windows)
+        self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+
+    def connect(self, host, port=False):
+        if not port:
+            protocol, buf = host.split('//')
+            host, port = buf.split(':')
+        if host in DNS_CACHE:
+            host = DNS_CACHE[host]
+        self.sock.connect((host, int(port)))
+        DNS_CACHE[host], port = self.sock.getpeername()
+
+    def disconnect(self):
+        # on Mac, the connection is automatically shutdown when the server disconnect.
+        # see http://bugs.python.org/issue4397
+        if sys.platform != 'darwin':
+            self.sock.shutdown(socket.SHUT_RDWR)
+        self.sock.close()
+
+    def send(self, msg, exception=False, traceback=None):
+        msg = cPickle.dumps([msg,traceback])
+        self.sock.sendall('%8d%s%s' % (len(msg), exception and "1" or "0", msg))
+
+    def receive(self):
+
+        def read(socket, size):
+            buf=''
+            while len(buf) < size:
+                chunk = self.sock.recv(size - len(buf))
+                if chunk == '':
+                    raise RuntimeError, "socket connection broken"
+                buf += chunk
+            return buf
+
+        size = int(read(self.sock, 8))
+        buf = read(self.sock, 1)
+        exception = buf != '0' and buf or False
+        res = cPickle.loads(read(self.sock, size))
+
+        if isinstance(res[0],Exception):
+            if exception:
+                raise TinySocketError(res[0], res[1])
+            raise res[0]
+        else:
+            return res[0]
+
+# vim: ts=4 sts=4 sw=4 si et

=== added directory 'nginx'
=== added file 'nginx/nok.png'
Binary files nginx/nok.png	1970-01-01 00:00:00 +0000 and nginx/nok.png	2011-10-26 10:12:24 +0000 differ
=== added file 'nginx/ok.png'
Binary files nginx/ok.png	1970-01-01 00:00:00 +0000 and nginx/ok.png	2011-10-26 10:12:24 +0000 differ
=== added file 'nginx/style.css'
--- nginx/style.css	1970-01-01 00:00:00 +0000
+++ nginx/style.css	2011-10-26 10:12:24 +0000
@@ -0,0 +1,4 @@
+.comment {
+   font-size: 10px;
+   padding-left: 20px;
+}

=== added file 'runbot.py'
--- runbot.py	1970-01-01 00:00:00 +0000
+++ runbot.py	2011-10-26 10:12:24 +0000
@@ -0,0 +1,767 @@
+#!/usr/bin/python
+
+import cgitb,os,re,subprocess,sys,time
+import argparse
+import fileinput
+import mako.template
+from lib import initdb
+import ConfigParser
+import psycopg2
+import psycopg2.extensions
+from bzrlib.branch import Branch
+from bzrlib.bzrdir import BzrDir
+from bzrlib.workingtree import WorkingTree
+from bzrlib.plugins.launchpad.lp_directory import LaunchpadDirectory
+import shutil
+import smtplib 
+from email.mime.text import MIMEText
+
+#----------------------------------------------------------
+# OpenERP rdtools utils
+#----------------------------------------------------------
+
+def write_pid(pidfile, pid):
+    pidf = open(pidfile, "w")
+    pidf.write("%d"%pid)
+    pidf.close()
+
+def log(*l,**kw):
+    out=[time.strftime("%Y-%m-%d %H:%M:%S")]
+    for i in l:
+        if not isinstance(i,basestring):
+            i=repr(i)
+        out.append(i)
+    out+=["%s=%r"%(k,v) for k,v in kw.items()]
+    sys.stdout.write(" ".join(out))
+    sys.stdout.write("\n")
+
+def run(l):
+    log("run",*l)
+    if isinstance(l,list):
+        rc=os.spawnvp(os.P_WAIT, l[0], l)
+    elif isinstance(l,str):
+        tmp=['sh','-c',l]
+        rc=os.spawnvp(os.P_WAIT, tmp[0], tmp)
+    return rc
+
+def kill(pid,sig=9):
+    try:
+        os.kill(pid,sig)
+    except OSError:
+        pass
+    
+def _is_running(pid):
+    if not pid:
+        return False
+    try:
+        os.kill(pid, 0)
+        return pid
+    except OSError:
+        return False
+
+def underscorize(n):
+    return n.replace("~","").replace(":","_").replace("/","_")
+
+#----------------------------------------------------------
+# OpenERP RunBot
+#----------------------------------------------------------
+
+class RunBotBranch(object):
+    def __init__(self,runbot, subfolder):
+        self.runbot=runbot
+        self.running=False
+        self.running_port=None
+        self.running_server_pid=None
+        self.running_web_pid=None
+        self.running_t0=None
+        self.date_last_modified=0
+        self.revision_count=0
+        self.merge_count=0
+
+        self.name = subfolder
+        self.unique_name = subfolder
+        self.project_name = subfolder
+        self.uname=underscorize(self.unique_name)
+
+        self.subdomain=subfolder
+        self.instance_path=os.path.join(self.runbot.wd, "running", self.subdomain)
+
+        self.server_path=os.path.join(self.instance_path,"unifield-server")
+        self.server_bin_path=os.path.join(self.server_path,"openerp-server.py")
+        if not os.path.exists(self.server_bin_path): # for 6.0 branches
+            self.server_bin_path=os.path.join(self.server_path,"bin","openerp-server.py")
+
+        self.data_path = os.path.join(self.instance_path,"unifield-data")
+
+        self.web_path=os.path.join(self.instance_path,"unifield-web")
+        self.etc_path = os.path.join(self.instance_path,"etc")
+        self.web_bin_path=os.path.join(self.web_path,"openerp-web.py")
+
+        self.log_path=os.path.join(self.instance_path, 'logs')
+        self.log_server_path=os.path.join(self.log_path,'server.txt')
+        self.log_web_path=os.path.join(self.log_path,'web.txt')
+        self.file_pidweb = os.path.join(self.instance_path,'etc','web.pid')
+        self.file_pidserver = os.path.join(self.instance_path,'etc','server.pid')
+        self.configfile = os.path.join(self.instance_path,'config.ini')
+        
+        self.ini = ConfigParser.ConfigParser()
+        self.ini.readfp(open(self.runbot.common_configfile, 'r'))
+        self.ini.read(self.configfile)
+        if not self.ini.has_section('global'):
+            self.ini.add_section('global')
+       
+    def write_ini(self):
+        f = open(self.configfile, "w")
+        self.ini.write(f)
+        f.close()
+
+    def remove_option(self, key):
+        try:
+            return self.ini.remove_option('global', key)
+        except ConfigParser.NoOptionError:
+            return False
+
+    def get_ini(self, key):
+        try:
+            return self.ini.get('global', key)
+        except ConfigParser.NoOptionError:
+            return False
+    
+    def get_int_ini(self, key):
+        try:
+            return self.ini.getint('global', key)
+        except ConfigParser.NoOptionError:
+            return False
+
+    def get_bool_ini(self, key, default=False):
+        try:
+            return self.ini.getboolean('global', key)
+        except ConfigParser.NoOptionError:
+            return default
+
+    def set_ini(self, key, value):
+        return self.ini.set('global', key, '%s'%value)
+
+    def is_web_running(self):
+        pid = self.pidweb()
+        return _is_running(pid)
+
+    def is_server_running(self):
+        pid = self.pidserver()
+        return _is_running(pid)
+
+    def _get_pid(self, pidfile):
+        if not os.path.isfile(pidfile):
+            return False
+        try:
+            pf = file(pidfile,'r')
+            pid = int(pf.read().strip())
+            pf.close()
+            return pid
+        except IOError:
+            return False
+        return False
+
+    def pidweb(self):
+        return self._get_pid(self.file_pidweb)
+
+    def pidserver(self):
+        return self._get_pid(self.file_pidserver)
+
+    def start_createdb(self):
+        dbname = self.subdomain.lower()
+        try:
+            conn = psycopg2.connect(database=dbname)
+            log("Database %s exists"%(dbname, ))
+        except psycopg2.OperationalError:
+            log("Creating database %s"%(dbname, ))
+            conn = psycopg2.connect(database='template1')
+            conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
+            c = conn.cursor()
+            c.execute('CREATE DATABASE %s'%(dbname, ))
+        conn.close()
+
+    def start_run_server(self,port):
+        if self.is_server_running():
+            log("run","Server %s already running ..."%(self.subdomain, ))
+            return True
+        
+        log("branch-start-run-server", self.project_name, port=port)
+        out=open(self.log_server_path,"a")
+        
+        config_file = os.path.join(self.instance_path,'etc', 'openerprc')
+
+        
+        dbname = self.subdomain.lower()
+        cmd=[self.server_bin_path,"-c",config_file, "-d",dbname,"--no-xmlrpc","--no-xmlrpcs","--netrpc-port=%d"%(port)]
+
+        modules = self.get_ini('modules')
+        if not modules:
+            modules = 'base'
+
+        if 'msf_profile' not in modules:
+            self.set_ini('load_data',0)
+
+        cmd += ['-i', modules]
+         
+        if self.get_bool_ini('load_data') or not self.get_bool_ini('load_demo'):
+                cmd.append("--without-demo=all")
+
+        log("run",*cmd,log=self.log_server_path)
+        p=subprocess.Popen(cmd, stdout=out, stderr=out, close_fds=True)
+        self.running_server_pid=p.pid
+        write_pid(self.file_pidserver, p.pid)
+    
+        if self.get_bool_ini('load_data') and not self.get_bool_ini('data_already_loaded'):
+            pid = os.fork()
+            if not pid:
+                self._symlink_nginx_icon('nok')
+                try:
+                    msg = initdb.connect_db('admin', 'admin', dbname, '127.0.0.1', port, self.data_path)
+                except Exception, e:
+                    self._email(str(e), True)
+                    log('init', self.name, str(e))
+                    sys.exit(1)
+                self._symlink_nginx_icon('ok')
+		if self.get_ini('comment'):
+			msg += "\n\n%s"%(self.get_ini('comment'), )
+                self._email(msg)
+                sys.exit(1)
+            self.set_ini('data_already_loaded', '1')
+        else:
+            self._symlink_nginx_icon('ok')
+
+    def _email(self, msg, err=False):
+        dest = self.get_ini('email')
+        if self.runbot.smtp_host and dest:
+            if err:
+                data ="Unable to initialize %s.\n\n%s\n\n"%(self.name, msg)
+            else:
+                data ="Your instance is ready: http://%s.%s\n%s\n\n"%(self.subdomain, self.runbot.domain, msg)
+
+
+            data += "http://%s"%(self.runbot.domain, )
+            msg = MIMEText(data)
+
+            msg['Subject'] = 'Runbot %s'%(self.name, )
+            msg['To'] = dest
+            msg['From'] = 'noreply@%s'%(self.runbot.domain, )
+
+            s = smtplib.SMTP(self.runbot.smtp_host)
+            s.sendmail(msg['From'], dest.split(','), msg.as_string())
+
+
+
+    def _symlink_nginx_icon(self, itype):
+        # assert itype in ['ok', 'nok']
+        dest = os.path.join(self.runbot.nginx_path, '%s.png'%(self.name,))
+        os.path.exists(dest) and os.remove(dest)
+        os.symlink(os.path.join(self.runbot.nginx_path,'%s.png'%(itype, )), dest)
+
+    def start_run_web(self,port):
+        if self.is_web_running():
+            log("run","Web %s already running ..."%(self.subdomain, ))
+            return True
+
+        config="""[global]
+server.environment = "development"
+server.socket_host = "0.0.0.0"
+server.socket_port = %d
+server.thread_pool = 10
+tools.sessions.on = True
+log.access_level = "INFO"
+log.error_level = "INFO"
+tools.csrf.on = False
+tools.log_tracebacks.on = False
+tools.cgitb.on = True
+openerp.server.host = 'localhost'
+openerp.server.port = %d
+openerp.server.protocol = 'socket'
+openerp.server.timeout = 1500
+tools.proxy.on = True
+[openerp-web]
+dblist.filter = 'BOTH'
+dbbutton.visible = True
+company.url = ''
+"""%(port+1,port)
+
+        config_file = os.path.join(self.etc_path,"openerp-web.cfg")
+        open(config_file,"w").write(config)
+
+        out=open(self.log_web_path,"a")
+        cmd=[self.web_bin_path, '-c', config_file]
+        
+        log("run",*cmd,log=self.log_web_path)
+        p=subprocess.Popen(cmd, stdout=out, stderr=out, close_fds=True)
+        self.running_web_pid=p.pid
+        write_pid(self.file_pidweb, p.pid)
+
+    def start(self):
+        port = self.get_int_ini('port')
+        log("branch-start",branch=self.unique_name,port=port)
+        
+        '''
+        Here check if the instance existed already, then do not drop and recreate the DB, just launch the server and web!
+        '''
+      
+        self.start_createdb()
+        self.start_run_server(port)
+        self.start_run_web(port)
+
+        self.runbot.running.insert(0,self)
+        self.runbot.running.sort(key=lambda x:x.date_last_modified,reverse=1)
+        self.running_t0=time.time()
+        self.running=True
+        self.running_port=port
+        self.write_ini()
+
+    def stop(self):
+        log("branch-stop",branch=self.unique_name,port=self.running_port)
+        pidserver = self.pidserver()
+        if pidserver:
+            log('Kill server %s'%(pidserver,))
+            kill(pidserver)
+        pidweb = self.pidweb()
+        if pidweb:
+            log('Kill server %s'%(pidweb,))
+            kill(pidweb)
+        if self in self.runbot.running:
+            self.runbot.running.remove(self)
+        self.running=False
+        self.running_port=None
+
+    def delete(self, onlydb):
+        self.stop()
+        log("Delete db %s"%self.subdomain.lower())
+        run(['dropdb', self.subdomain.lower()])
+        if not onlydb:
+            log("Delete %s"%self.instance_path)
+            shutil.rmtree(self.instance_path)
+            try:
+                os.remove(os.path.join(self.runbot.nginx_path, '%s.png'%(self.name, )))
+            except OSError, e:
+                pass
+        else:
+            self.set_ini('data_already_loaded',0)
+            self.write_ini()
+
+        del(self.runbot.uf_instances[self.name])
+
+class RunBot(object):
+    def __init__(self, wd, server_port, nginx_port, domain, init, smtp_host):
+        self.wd=wd
+        self.common_path = os.path.join(self.wd,"common")
+        self.common_etc = os.path.join(self.common_path,"etc")
+        self.common_configfile = os.path.join(self.common_etc,"default_config.ini")
+        self.server_port=int(server_port)
+        self.nginx_port=int(nginx_port)
+        self.domain=domain
+        self.uf_instances={}
+        self.now = time.strftime("%Y-%m-%d %H:%M:%S")
+        self.running=[]
+        self.nginx_path = os.path.join(self.wd,'nginx')
+        self.nginx_pid_path = os.path.join(self.nginx_path,'nginx.pid')
+        self.smtp_host = smtp_host
+        
+        self.running_path=os.path.join(self.wd, "running")
+        allsubdirs = self.subdirs(self.running_path) # in consumption that the sub-folder NAMES are valid
+
+        for folder in allsubdirs:
+            rbb=self.uf_instances.setdefault(folder, RunBotBranch(self,folder))
+            if init and rbb.get_bool_ini('start',True):
+                self.init_folder(rbb)
+
+    def is_nginx_running(self):
+        return _is_running(self.nginx_pid())
+
+    def nginx_pid(self):
+        if os.path.isfile(self.nginx_pid_path):
+            return int(open(self.nginx_pid_path).read())
+        else:
+            return False
+
+    def nginx_reload(self):
+        pid = self.nginx_pid()
+        if pid:
+            os.kill(pid,1)
+        else:
+            run(["/usr/sbin/nginx","-p", self.wd + "/", "-c", os.path.join(self.nginx_path,"nginx.conf")])
+
+    def nginx_config(self):
+        template="""
+        pid nginx/nginx.pid;
+        error_log nginx/error.log;
+        worker_processes  1;
+        events { worker_connections  1024; }
+        http {
+          include /etc/nginx/mime.types;
+          server_names_hash_bucket_size 128;
+          autoindex on;
+          client_body_temp_path nginx; proxy_temp_path nginx; fastcgi_temp_path nginx; access_log nginx/access.log; index index.html;
+          server { listen ${r.nginx_port} default; server_name _; root ./nginx/; }
+          % for i in r.running:
+             server {
+                listen ${r.nginx_port};
+                server_name ${i.subdomain}.${r.domain};
+                location /${i.subdomain}/logs/ { alias ${i.log_path}/; }
+                location / { proxy_pass http://127.0.0.1:${i.running_port+1}; proxy_set_header X-Forwarded-Host $host; }
+             }
+          % endfor
+        }
+        """
+        return mako.template.Template(template).render(r=self)
+
+    def nginx_index_time(self,t):
+        for m,u in [(86400,'d'),(3600,'h'),(60,'m')]:
+            if t>=m:
+                return str(int(t/m))+u
+        return str(int(t))+"s"
+
+    def nginx_index(self):
+        template = """<!DOCTYPE html>
+        <html>
+        <head>
+        <title>UniField Runbot</title>
+        <link rel="shortcut icon" href="/favicon.ico" />
+        <link rel="stylesheet" href="style.css" type="text/css">
+        </head>
+        <body id="indexfile">
+        <div id="header">
+            <div class="content"><h1>UniField Manual Runbot</h1> </div>
+        </div>
+        <div id="index">
+        <table class="index">
+        <thead>
+        <tr>
+            <td colspan='3'><hr/></td>
+        </tr>
+        <tr class="tablehead">
+            <th class="name left" align="left">UniField test instance</th>
+            <th>Date</th>
+            <th>Logs</th>
+        </tr>
+        <tr>
+            <td colspan='3'><hr/></td>
+        </tr>
+        <tr>
+            <td colspan='3'></td>
+        </tr>
+        </thead>
+        <tfoot>
+        <tr>
+            <td colspan='3'></td>
+        </tr>
+        <tr>
+            <td colspan='3'></td>
+        </tr>
+        <tr class="total">
+            <td class="name left"><b>${len(r.running)} UniField test instances</b></td>
+            <td></td>
+            <td></td>
+            <td class="right"></td>
+        </tr>
+        </tfoot>
+        <tbody>
+        % for i in r.running:
+        <tr class="file">
+            <td class="name left">
+                <a href="http://${i.subdomain}.${r.domain}/"  target="_blank">${i.subdomain}</a> <small>(netrpc: ${i.running_port+1})</small> <img src="${i.subdomain}.png" alt=""/>
+            </td>
+            <td class="date">
+                % if t-i.running_t0 < 120:
+                    <span style="color:red;">${r.now}</span>
+                % else:
+                    <span style="color:green;">${r.now}</span>
+                % endif
+            </td>
+            <td>
+                <a href="http://${i.subdomain}.${r.domain}/${i.subdomain}/logs/server.txt">server</a>
+                <a href="http://${i.subdomain}.${r.domain}/${i.subdomain}/logs/web.txt">web</a>
+            </td>
+        </tr>
+             % if i.get_ini('comment'):
+                <tr>
+                   <td colspan="3" class="comment">${i.get_ini('comment')}</td>
+             % endif
+        % endfor
+        <tr>
+            <td colspan='3'><hr/></td>
+        </tr>
+        <tr>
+            <td colspan='3'></td>
+        </tr>
+        </tbody>
+        </table>
+        </div>
+        <div id="footer">
+            <div class="content">
+                <p><b>Last modification: ${r.now}.</b></p>
+            </div>
+        </div>
+        </body>
+        """
+        self.now = time.strftime("%Y-%m-%d %H:%M:%S")
+        return mako.template.Template(template).render(r=self,t=time.time(),re=re)
+
+    def nginx_udpate(self):
+        """ Update the link, port and entry of the new UniField instance into 2 files: nginx.conf and index.html
+        """
+        log("runbot-nginx-update")
+        f=open(os.path.join(self.wd,'nginx','index.html'),"w")
+        f.write(self.nginx_index())
+        f.close()
+        f=open(os.path.join(self.wd,'nginx','nginx.conf'),"w")
+        f.write(self.nginx_config())
+        f.close()
+        self.nginx_reload()
+
+    def _get_port(self):
+        i = self.server_port
+        while i in self.ports:
+            i += 2
+        return i
+
+    def subdirs(self, dir):
+        '''
+        Retrieve the direct sub folders of the given folder 
+        '''
+        return [name for name in os.listdir(dir)
+            if os.path.isdir(os.path.join(dir, name)) and not name.startswith('.')]
+
+    def process_instances(self):
+        log("runbot-folder")
+
+        ''' 
+        Get the sub folders and build a list of instances to be run 
+        '''
+        self.ports = []
+        for rbb in self.uf_instances.values():
+            num_port = rbb.get_int_ini('port')
+            if num_port:
+                self.ports.append(num_port)
+                self.ports.append(num_port+1)
+        
+        for rbb in self.uf_instances.values():
+            if not rbb.get_int_ini('port'):
+                new_port = self._get_port()
+                self.ports.append(new_port)
+                self.ports.append(new_port+1)
+                rbb.set_ini('port', new_port)
+            if rbb.get_bool_ini('start',True):
+                rbb.start()
+            
+        self.nginx_udpate()
+
+        
+    def init_folder(self, rbb):
+
+        ''' To do the following things if not exist
+            - create the logs folder for storing log files
+            - create soft-link to: unifield-server, unifield-addons, unifield-web if not exist (in case no change has been made)
+        '''
+        
+        logs_dir = os.path.join(rbb.instance_path, "logs")
+        if not os.path.exists(logs_dir):
+            os.mkdir(logs_dir)
+
+        # copy the unifield-server project from 'common' folder if not existed
+        self.create_module(rbb, "unifield-server")
+        self.create_module(rbb, "unifield-web")
+        # copy the folder 'etc' from 'common' folder, then fill the instance path
+        self.process_folder_etc(rbb)
+
+        # create softlinks for these 3 projects if not existed
+        self.create_module(rbb, "unifield-addons")
+        self.create_module(rbb, "unifield-wm")
+        self.create_module(rbb, "unifield-data")
+
+
+    def process_folder_etc(self, rbb):
+        # delete and recopy the folder "etc"
+        project_path = rbb.etc_path
+        #run(["rm","-r", project_path]) # delete first
+        
+        if not os.path.exists(os.path.join(project_path)):
+            run(["cp","-r", self.common_etc, rbb.instance_path])
+        
+            # replace the UF_ADDONS_PATH with the modules path of the current instance 
+            config_file = os.path.join(project_path, 'openerprc')
+            for line in fileinput.FileInput(config_file, inplace=1):
+                line = line.replace("UF_ADDONS_PATH", rbb.instance_path)
+                line = line.replace("UF_INSTANCE", rbb.name)
+                line = line.replace("PIDFILE", rbb.file_pidserver)
+                sys.stdout.write(line)
+
+    def create_module(self, rbb, module):
+        project_path = os.path.join(rbb.instance_path, module)
+        common_project_path = os.path.join(self.common_path, module)
+        if not os.path.exists(project_path):
+            source_module = rbb.get_ini(module)
+            if not source_module or source_module == 'link':
+                log('Link module %s'%(module, ))
+                run(["ln","-s", common_project_path, project_path])
+            else:
+                directory = LaunchpadDirectory()
+                d = directory._resolve(source_module)
+                log('bzr checkout %s'%(d, ))
+                br = Branch.open(d)
+
+                # for symlink
+                common_project_path = os.path.realpath(common_project_path)
+                orig = WorkingTree.open(common_project_path)
+                br.create_checkout(project_path, lightweight=True, accelerator_tree=orig)
+                br.repository._client._medium.disconnect()
+
+
+def skel(o, r):
+    if o.instance in r.uf_instances:
+        sys.stderr.write("Error: %s exists\n"%(o.instance, ))
+    else:
+        new_folder = os.path.join(r.running_path, o.instance)
+        os.mkdir(new_folder)
+        new_ini = os.path.join(new_folder, 'config.ini')
+        shutil.copy(r.common_configfile, new_ini)
+        inf = open(r.common_configfile, 'r')
+        outf = open(new_ini, "w")
+        for line in inf:
+            if line.startswith('comment'):
+                outf.write("comment = %s\n"%(o.comment or ""))
+            elif line.startswith('email'):
+                outf.write("email = %s\n"%(o.email or ""))
+            elif line.startswith('unifield-wm'):
+                outf.write("unifield-wm = %s\n"%(o.unifield_wm or "link"))
+            elif o.unit and line.startswith('load_demo'):
+                outf.write("load_demo = 1\n")
+            elif o.unit and line.startswith('load_data'):
+                outf.write("load_data = 0\n")
+            else:
+                outf.write(line)
+        inf.close()
+        if o.start:
+            outf.close()
+            rbb = r.uf_instances.setdefault(o.instance, RunBotBranch(r,o.instance))
+            r.init_folder(rbb)
+            r.process_instances() 
+        else:
+            outf.write("start = 0")
+            sys.stderr.write("Please edit %s , and change 'start',\nyou can use vi or a friendlier editor like nano\n"%(new_ini, ))
+            outf.close()
+
+
+def killall(o, r):
+    for rbb in r.uf_instances.values():
+        rbb.stop()
+    
+def kill_inst(o, r):
+    if o.instance not in r.uf_instances:
+        sys.stderr.write("%s not in instance\n"%o.instance)
+    else:
+        r.uf_instances[o.instance].stop()
+    
+def list_inst(o, r):
+    sys.stderr.write("Nginx ")
+    pid = r.is_nginx_running()
+    if pid:
+        sys.stderr.write("running on port: %s, pid: %s\n"%(r.nginx_port, pid))
+    else:
+        sys.stderr.write("isn't running\n")
+
+    for rbb in r.uf_instances.values():
+        sys.stderr.write("Instance %s:\n"%(rbb.name, ))
+        if not rbb.get_bool_ini('start',True):
+            sys.stderr.write("    Disabled in config.ini\n")
+        sys.stderr.write("    web: %s\n"%(rbb.is_web_running() and 'running on port %s, pid %s'%(rbb.get_int_ini('port')+1, rbb.pidweb()) or 'not running', ))
+        sys.stderr.write("    server: %s\n"%(rbb.is_server_running() and 'running on port %s, pid %s'%(rbb.get_int_ini('port'), rbb.pidserver()) or 'not running'))
+    
+def restartall(o, r):
+    for rbb in r.uf_instances.values():
+        rbb.stop()
+    time.sleep(1)
+    run_inst(o, r)
+
+def run_inst(o, r):
+    r.process_instances()
+    
+def restart(o, r):
+    if o.instance not in r.uf_instances:
+        sys.stderr.write("%s not in instance\n"%o.instance)
+    else:
+        r.uf_instances[o.instance].stop()
+        run_inst(o, r)
+
+def del_inst(o, r):
+    if o.instance not in r.uf_instances:
+        sys.stderr.write("%s not in instance\n"%o.instance)
+    else:
+        r.uf_instances[o.instance].delete(o.only_db)
+        run_inst(o, r)
+
+def main():
+
+    os.chdir(os.path.normpath(os.path.dirname(__file__)))
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+    parser.add_argument("--runbot-dir", metavar="DIR", default=".", help="runbot working dir (default: %(default)s)")
+    parser.add_argument("--runbot-port", metavar="PORT", default=9200, help="starting port for servers (default: %(default)s)")
+    parser.add_argument("--runbot-nginx-port", metavar="PORT", default=9100, help="starting port for nginx server (default: %(default)s)")
+    parser.add_argument("--runbot-nginx-domain", metavar="DOMAIN", default="runbot.unifield.org", help="virtual host domain (default: %(default)s)")
+    parser.add_argument("--debug", action="store_true", default=False, help="print debug on stdout (default: %(default)s)")
+    parser.add_argument("--smtp-host", metavar="HOST", default='localhost', help="smtp server (default: %(default)s)")
+    subparsers = parser.add_subparsers(dest='command')
+    run_parser = subparsers.add_parser('run', help='start/init new instances')
+    run_parser.set_defaults(func=run_inst)
+
+    killall_parser = subparsers.add_parser('killall', help='kill all instances')
+    killall_parser.set_defaults(func=killall)
+
+    kill_parser = subparsers.add_parser('kill', help='kill an instance')
+    kill_parser.add_argument('instance', action='store', help='instance to kill')
+    kill_parser.set_defaults(func=kill_inst)
+    
+    restartall_parser = subparsers.add_parser('restartall', help='restart all instances')
+    restartall_parser.set_defaults(func=restartall)
+
+    restart_parser = subparsers.add_parser('restart', help='restart an instance')
+    restart_parser.add_argument('instance', action='store', help='instance to kill')
+    restart_parser.set_defaults(func=restart)
+    
+    list_parser = subparsers.add_parser('list', help='list all instances')
+    list_parser.set_defaults(func=list_inst)
+
+    skel_parser = subparsers.add_parser('skel', help='create a directory for a new instance')
+    skel_parser.add_argument('instance', action='store', help='instance')
+    skel_parser.add_argument('--start', action='store_true', default=False, help='Start this instance')
+    skel_parser.add_argument('--unit', action='store_true', default=False, help='Run instance with unit test (load demo)')
+    skel_parser.add_argument('--unifield-wm', metavar='URL', default='link', help='Launchpad url or keyword "link" (default: %(default)s)')
+    skel_parser.add_argument('--comment')
+    skel_parser.add_argument('--email')
+    skel_parser.set_defaults(func=skel)
+    
+    delete_parser = subparsers.add_parser('delete', help='delete an instance')
+    delete_parser.add_argument('instance', action='store', help='instance')
+    delete_parser.add_argument("--only-db", action="store_true", default=False, help="delete the database and not the directory (default: delete db+directory)")
+    delete_parser.set_defaults(func=del_inst)
+
+    o = parser.parse_args()
+    if (o.runbot_dir == '.'):
+        o.runbot_dir = os.getcwd() #get the full path for the current working directory
+    
+    invalid_character = ['-']
+        
+    for char in invalid_character:
+        if char in o.instance:
+            raise Exception('\'%s\' is an invalid character in the name of the instance' % char)
+
+    fsock = False
+    if not o.debug:
+        fsock = open('out.log', 'a')
+        sys.stdout = fsock
+    init = o.command == 'run'
+    r = RunBot(o.runbot_dir, o.runbot_port, o.runbot_nginx_port, o.runbot_nginx_domain, init, o.smtp_host)
+    o.func(o, r)
+    if fsock:
+        fsock.close()
+    
+
+if __name__ == '__main__':
+    main()

=== added directory 'running'