~openerp/openobject-server/old_trunk

« back to all changes in this revision

Viewing changes to bin/addons/quality_integration_server/base_quality_interrogation.py

  • Committer: mra (Open ERP)
  • Date: 2009-09-30 06:56:37 UTC
  • Revision ID: mra@tinyerp.com-20090930065637-v5py8qtfxaq04xov
[IMP] base_quality_interrrogation: put message if the score of quality less then minimal and remove unit test condition

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# -*- encoding: utf-8 -*-
2
2
##############################################################################
3
3
#
4
 
#    OpenERP, Open Source Management Solution    
 
4
#    OpenERP, Open Source Management Solution
5
5
#    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>). All Rights Reserved
6
6
#    $Id$
7
7
#
49
49
            except UnicodeError:
50
50
                return s
51
51
 
52
 
def start_server(root_path, port, addons_path):    
53
 
    os.system('python2.5 %sopenerp-server.py  --pidfile=openerp.pid  --port=%s --no-netrpc --addons-path=%s' %(root_path, str(port), addons_path))    
 
52
def start_server(root_path, port, addons_path):
 
53
    os.system('python2.5 %sopenerp-server.py  --pidfile=openerp.pid  --port=%s --no-netrpc --addons-path=%s' %(root_path, str(port), addons_path))
54
54
def clean():
55
55
    if os.path.isfile('openerp.pid'):
56
 
        ps = open('openerp.pid') 
 
56
        ps = open('openerp.pid')
57
57
        if ps:
58
58
            pid = int(ps.read())
59
 
            ps.close()  
60
 
            if pid:    
 
59
            ps.close()
 
60
            if pid:
61
61
                os.kill(pid,9)
62
62
 
63
63
def execute(connector, method, *args):
64
 
    global wait_count 
 
64
    global wait_count
65
65
    res = False
66
 
    try:        
 
66
    try:
67
67
        res = getattr(connector,method)(*args)
68
 
    except socket.error,e:        
69
 
        if e.args[0] == 111:                                   
 
68
    except socket.error,e:
 
69
        if e.args[0] == 111:
70
70
            if wait_count > wait_limit:
71
71
                print "Server is taking too long to start, it has exceeded the maximum limit of %d seconds."%(wait_limit)
72
72
                clean()
78
78
        else:
79
79
            raise e
80
80
    wait_count = 0
81
 
    return res                    
 
81
    return res
82
82
 
83
83
def login(uri, dbname, user, pwd):
84
84
    conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/common')
85
 
    uid = execute(conn,'login',dbname, user, pwd) 
 
85
    uid = execute(conn,'login',dbname, user, pwd)
86
86
    return uid
87
87
 
88
 
def import_translate(uri, user, pwd, dbname, translate_in):      
89
 
    uid = login(uri, dbname, user, pwd)    
90
 
    if uid:        
 
88
def import_translate(uri, user, pwd, dbname, translate_in):
 
89
    uid = login(uri, dbname, user, pwd)
 
90
    if uid:
91
91
        conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')
92
92
        wiz_id = execute(conn,'create',dbname, uid, pwd, 'module.lang.import')
93
93
        for trans_in in translate_in:
94
 
            lang,ext = os.path.splitext(trans_in.split('/')[-1])                
95
 
            state = 'init'  
 
94
            lang,ext = os.path.splitext(trans_in.split('/')[-1])
 
95
            state = 'init'
96
96
            datas = {'form':{}}
97
 
            while state!='end':                
 
97
            while state!='end':
98
98
                res = execute(conn,'execute',dbname, uid, pwd, wiz_id, datas, state, {})
99
99
                if 'datas' in res:
100
100
                    datas['form'].update( res['datas'].get('form',{}) )
110
110
                    })
111
111
                    trans_obj.close()
112
112
                elif res['type']=='action':
113
 
                    state = res['state']                    
114
 
                
115
 
        
116
 
def check_quality(uri, user, pwd, dbname, modules, quality_logs):       
 
113
                    state = res['state']
 
114
 
 
115
 
 
116
def check_quality(uri, user, pwd, dbname, modules, quality_logs):
117
117
    uid = login(uri, dbname, user, pwd)
118
118
    quality_logs += 'quality-logs'
119
119
    if uid:
120
120
        conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
121
 
        final = {}   
122
 
        for module in modules:   
 
121
        final = {}
 
122
        for module in modules:
123
123
            qualityresult = {}
124
 
            test_detail = {}              
 
124
            test_detail = {}
125
125
            quality_result = execute(conn,'execute', dbname, uid, pwd,'module.quality.check','check_quality',module)
126
126
            detail_html = ''
127
127
            html = '''<html><body><a name="TOP"></a>'''
128
 
            html +="<h1> Module : %s </h1>"%(quality_result['name'])   
129
 
            html += "<h2> Final score : %s</h2>"%(quality_result['final_score'])
 
128
            html +="<h1> Module: %s </h1>"%(quality_result['name'])
 
129
            html += "<h2> Final score: %s</h2>"%(quality_result['final_score'])
130
130
            html += "<div id='tabs'>"
131
131
            html += "<ul>"
132
 
            for x,y,detail in quality_result['check_detail_ids']:                
 
132
            for x,y,detail in quality_result['check_detail_ids']:
133
133
                test = detail.get('name')
134
134
                msg = detail.get('message','')
135
135
                score = round(float(detail.get('score',0)),2)
136
136
                html += "<li><a href=\"#%s\">%s</a></li>"%(test.replace(' ','-'),test)
137
 
                if test == 'Unit Test':
138
 
                    if not detail.get('detail',''):
139
 
                        detail['detail'] = '''<html><body><b>%s</b></body></html>'''%(detail.get('summary',''))
140
 
                detail_html +="<div id=\"%s\"><h3>%s (Score : %s)</h3>%s</div>"%(test.replace(' ','-'),test,score,detail.get('detail',''))                
 
137
                detail_html +='''<div id=\"%s\"><h3>%s (Score : %s)</h3><font color=red><h5>%s</h5></font>%s</div>'''%(test.replace(' ', '-'), test, score, msg, detail.get('detail', ''))
141
138
                test_detail[test] = (score,msg,detail.get('detail',''))
142
139
            html += "</ul>"
143
140
            html += "%s"%(detail_html)
155
152
        #print "LOG PATH%s"%(os.path.realpath('quality_log.pck'))
156
153
        return True
157
154
    else:
158
 
        print 'Login Failed...'        
 
155
        print 'Login Failed...'
159
156
        clean()
160
 
        sys.exit(1)     
 
157
        sys.exit(1)
161
158
 
162
159
 
163
160
 
176
173
    login_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/common')
177
174
    db_list = execute(conn, 'list')
178
175
    if dbname not in db_list:
179
 
        id = execute(conn,'create',admin_passwd, dbname, True, lang) 
 
176
        id = execute(conn,'create',admin_passwd, dbname, True, lang)
180
177
        wait(id,uri)
181
 
    uid = login_conn.login(dbname, user, pwd)   
 
178
    uid = login_conn.login(dbname, user, pwd)
182
179
 
183
180
    wiz_id = execute(wiz_conn,'create', dbname, uid, user, 'base_setup.base_setup')
184
181
 
185
182
    state = 'init'
186
183
    datas = {'form':{}}
187
184
 
188
 
    while state!='config':        
 
185
    while state!='config':
189
186
        res = execute(wiz_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
190
187
        if state=='init':
191
188
            datas['form'].update( res['datas'] )
192
189
        if res['type']=='form':
193
 
            for field in res['fields'].keys():               
 
190
            for field in res['fields'].keys():
194
191
                datas['form'][field] = datas['form'].get(field,False)
195
192
            state = res['state'][-1][0]
196
193
            datas['form'].update({
197
 
                'profile': -1                
 
194
                'profile': -1
198
195
            })
199
196
        elif res['type']=='state':
200
197
            state = res['state']
206
203
    conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/db')
207
204
    db_list = execute(conn,'list')
208
205
    if dbname in db_list:
209
 
        execute(conn, 'drop', admin_passwd, dbname)    
 
206
        execute(conn, 'drop', admin_passwd, dbname)
210
207
    return True
211
 
    
 
208
 
212
209
def make_links(uri, uid, dbname, source, destination, module, user, pwd):
213
210
    if module in ('base','quality_integration_server'):
214
 
        return True  
215
 
    if not os.path.islink(destination + '/' + module): 
216
 
        if not os.path.isdir(destination + '/' + module):    
 
211
        return True
 
212
    if not os.path.islink(destination + '/' + module):
 
213
        if not os.path.isdir(destination + '/' + module):
217
214
            for path in source:
218
215
                if os.path.isdir(path + '/' + module):
219
216
                    os.symlink(path + '/' + module, destination + '/' + module)
220
217
                    obj_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
221
218
                    execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'update_list')
222
219
                    module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','=',module)])
223
 
                    if len(module_ids):    
 
220
                    if len(module_ids):
224
221
                        data = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'read', module_ids[0],['name','dependencies_id'])
225
222
                        dep_datas = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module.dependency', 'read', data['dependencies_id'],['name'])
226
 
                        for dep_data in dep_datas:    
 
223
                        for dep_data in dep_datas:
227
224
                            make_links(uri, uid, dbname, source, destination, dep_data['name'], user, pwd)
228
 
                    return True    
229
 
    return False    
 
225
                    return True
 
226
    return False
230
227
 
231
228
def install_module(uri, dbname, modules, addons='', extra_addons='',  user='admin', pwd='admin'):
232
229
    uid = login(uri, dbname, user, pwd)
233
230
    if extra_addons:
234
231
        extra_addons = extra_addons.split(',')
235
 
    if uid: 
 
232
    if uid:
236
233
        if addons and extra_addons:
237
 
            for module in modules:  
238
 
                make_links(uri, uid, dbname, extra_addons, addons, module, user, pwd) 
 
234
            for module in modules:
 
235
                make_links(uri, uid, dbname, extra_addons, addons, module, user, pwd)
239
236
 
240
237
        obj_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
241
238
        wizard_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')
242
239
        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])
243
 
        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_install', module_ids)           
 
240
        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_install', module_ids)
244
241
        wiz_id = execute(wizard_conn, 'create', dbname, uid, pwd, 'module.upgrade.simple')
245
242
        state = 'init'
246
243
        datas = {}
247
244
        #while state!='menu':
248
 
        while state!='end':                
249
 
            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})                
 
245
        while state!='end':
 
246
            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
250
247
            if state == 'init':
251
248
                state = 'start'
252
249
            elif state == 'start':
253
 
                state = 'end'                                  
 
250
                state = 'end'
254
251
    return True
255
252
 
256
253
def upgrade_module(uri, dbname, modules, user='admin', pwd='admin'):
257
254
    uid = login(uri, dbname, user, pwd)
258
 
    if uid: 
 
255
    if uid:
259
256
        obj_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
260
 
        wizard_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')        
261
 
        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])  
262
 
        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_upgrade', module_ids)           
 
257
        wizard_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')
 
258
        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])
 
259
        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_upgrade', module_ids)
263
260
        wiz_id = execute(wizard_conn, 'create', dbname, uid, pwd, 'module.upgrade.simple')
264
261
        state = 'init'
265
262
        datas = {}
266
263
        #while state!='menu':
267
 
        while state!='end':                
268
 
            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})                
 
264
        while state!='end':
 
265
            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
269
266
            if state == 'init':
270
267
                state = 'start'
271
268
            elif state == 'start':
272
 
                state = 'end'                                  
273
 
                            
 
269
                state = 'end'
 
270
 
274
271
    return True
275
272
 
276
273
 
283
280
    start-server         Start Server
284
281
    create-db            Create new database
285
282
    drop-db              Drop database
286
 
    install-module       Install module 
 
283
    install-module       Install module
287
284
    upgrade-module       Upgrade module
288
285
    install-translation  Install translation file
289
286
    check-quality        Calculate quality and dump quality result into quality_log.pck using pickle
290
287
"""
291
 
parser = optparse.OptionParser(usage)            
 
288
parser = optparse.OptionParser(usage)
292
289
parser.add_option("--modules", dest="modules",
293
290
                     help="specify modules to install or check quality")
294
291
parser.add_option("--addons-path", dest="addons_path", help="specify the addons path")
295
292
parser.add_option("--quality-logs", dest="quality_logs", help="specify the path of quality logs files which has to stores")
296
293
parser.add_option("--root-path", dest="root_path", help="specify the root path")
297
294
parser.add_option("-p", "--port", dest="port", help="specify the TCP port", type="int")
298
 
parser.add_option("-d", "--database", dest="db_name", help="specify the database name")  
299
 
parser.add_option("--login", dest="login", help="specify the User Login") 
300
 
parser.add_option("--password", dest="pwd", help="specify the User Password")  
 
295
parser.add_option("-d", "--database", dest="db_name", help="specify the database name")
 
296
parser.add_option("--login", dest="login", help="specify the User Login")
 
297
parser.add_option("--password", dest="pwd", help="specify the User Password")
301
298
parser.add_option("--translate-in", dest="translate_in",
302
299
                     help="specify .po files to import translation terms")
303
300
parser.add_option("--extra-addons", dest="extra_addons",
308
305
    parser.error("incorrect number of arguments")
309
306
command = args[0]
310
307
if command not in ('start-server','create-db','drop-db','install-module','upgrade-module','check-quality','install-translation'):
311
 
    parser.error("incorrect command")    
 
308
    parser.error("incorrect command")
312
309
 
313
310
def die(cond, msg):
314
311
    if cond:
326
323
    'quality-logs' : opt.quality_logs or '',
327
324
    'root-path' : opt.root_path or '',
328
325
    'translate-in': [],
329
 
    'port' : opt.port or 8069,        
 
326
    'port' : opt.port or 8069,
330
327
    'database': opt.db_name or 'terp',
331
328
    'modules' : opt.modules or [],
332
329
    'login' : opt.login or 'admin',
337
334
options['modules'] = opt.modules and map(lambda m: m.strip(), opt.modules.split(',')) or []
338
335
# Hint:i18n-import=purchase:ar_AR.po+sale:fr_FR.po,nl_BE.po
339
336
if opt.translate_in:
340
 
    translate = opt.translate_in     
341
 
    for module_name,po_files in map(lambda x:tuple(x.split(':')),translate.split('+')):                          
342
 
        for po_file in po_files.split(','):                   
 
337
    translate = opt.translate_in
 
338
    for module_name,po_files in map(lambda x:tuple(x.split(':')),translate.split('+')):
 
339
        for po_file in po_files.split(','):
343
340
            po_link = '%s/%s/i18n/%s'%(options['addons-path'], module_name, po_file)
344
 
            options['translate-in'].append(po_link) 
345
 
           
 
341
            options['translate-in'].append(po_link)
 
342
 
346
343
uri = 'http://localhost:' + str(options['port'])
347
344
 
348
345
server_thread = threading.Thread(target=start_server,
349
346
                args=(options['root-path'], options['port'], options['addons-path']))
350
 
try:    
351
 
    server_thread.start()       
352
 
    if command == 'create-db': 
 
347
try:
 
348
    server_thread.start()
 
349
    if command == 'create-db':
353
350
        create_db(uri, options['database'], options['login'], options['pwd'])
354
 
    if command == 'drop-db': 
 
351
    if command == 'drop-db':
355
352
        drop_db(uri, options['database'])
356
 
    if command == 'install-module': 
 
353
    if command == 'install-module':
357
354
        install_module(uri, options['database'], options['modules'],options['addons-path'],options['extra-addons'],options['login'], options['pwd'])
358
 
    if command == 'upgrade-module': 
 
355
    if command == 'upgrade-module':
359
356
        upgrade_module(uri, options['database'], options['modules'], options['login'], options['pwd'])
360
357
    if command == 'check-quality':
361
358
        check_quality(uri, options['login'], options['pwd'], options['database'], options['modules'], options['quality-logs'])
362
 
    if command == 'install-translation':        
 
359
    if command == 'install-translation':
363
360
        import_translate(uri, options['login'], options['pwd'], options['database'], options['translate-in'])
364
361
    clean()
365
362
    sys.exit(0)
366
 
    
 
363
 
367
364
except xmlrpclib.Fault, e:
368
365
    print e.faultString
369
366
    clean()
372
369
    print e
373
370
    clean()
374
371
    sys.exit(1)
375
 
    
 
372
 
376
373
 
377
374
 
378
375