Changeset 6450


Ignore:
Timestamp:
Dec 12, 2017, 3:04:30 PM (2 years ago)
Author:
mabarracus
Message:

Use unicode literals into code

Location:
hwdetector/trunk/fuentes
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • hwdetector/trunk/fuentes/debian/changelog

    r6446 r6450  
     1hwdetector (0.1.7.3) unreleased; urgency=medium
     2
     3  * Use unicode literals into code
     4
     5 -- M.Angel Juan <m.angel.juan@gmail.com>  Tue, 12 Dec 2017 15:03:42 +0100
     6
    17hwdetector (0.1.7.2) xenial; urgency=medium
    28
  • hwdetector/trunk/fuentes/debian/control

    r6401 r6450  
    1717Package: valentin
    1818Architecture: all
    19 Depends: ${shlibs:Depends}, ${misc:Depends}, hwdetector
     19Depends: ${shlibs:Depends}, ${misc:Depends}, hwdetector, python-gi
    2020Description: Diagnosys system
    2121 Simple system detector with system checks and hints
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/Detector.py

    r6399 r6450  
    22from functools import wraps
    33import hwdetector.utils.log as log
    4 #log.debug("File "+__name__+" loaded")
     4#log.debug(u'File '+__name__+u' loaded')
    55
    66import dill as pickle
     
    1515
    1616    def __init__(self):
    17         log.debug("Init detector base class")
     17        log.debug(u'Init detector base class')
    1818
    1919    def run(self,*args,**kwargs):
    20         log.warning("Running fake run method from base class")
     20        log.warning(u'Running fake run method from base class')
    2121        pass
    2222
    2323    def toString(self):
    24         log.debug("Calling toString base class")
    25         log.debug("My name is: {}".format( __name__))
    26         log.debug('My needs are: {}'.format(self._NEEDS))
    27         log.debug('My provides are: {}'.format(self._PROVIDES))
     24        log.debug(u'Calling toString base class')
     25        log.debug(u'My name is: {}'.format( __name__))
     26        log.debug(u'My needs are: {}'.format(self._NEEDS))
     27        log.debug(u'My provides are: {}'.format(self._PROVIDES))
    2828
    2929class Detector(_Detector):
     
    3131        @wraps(func)
    3232        def wrapper(self,*args, **kwargs):
    33             # first argument is class instance -> "self"
     33            # first argument is class instance -> u'self'
    3434            # second argument is the first param passed to instance
    3535            ret = None
    3636            try:
    3737                args = args[1:]
    38                 out = kwargs['out']
    39                 del kwargs['out']
     38                out = kwargs[u'out']
     39                del kwargs[u'out']
    4040                ret = func(self,*args, **kwargs)
    4141                if ret:
    4242                    for k in ret.keys():
    43                         if k[0:6].lower() == 'helper':
     43                        if k[0:6].lower() == u'helper':
    4444                            ret[k]=pickle.dumps(ret[k])
    4545                else:
     
    4747                out.send(ret)
    4848            except Exception as e:
    49                 log.error('Exception in plugin({}): {}'.format(self.__class__.__name__,e))
    50                 log.error('Traceback:\n{}'.format(traceback.format_exc()))
     49                log.error(u'Exception in plugin({}): {}'.format(self.__class__.__name__,e))
     50                log.error(u'Traceback:\n{}'.format(traceback.format_exc()))
    5151                return None
    5252            return ret
     
    5757    def _run(self,*args,**kwargs):
    5858        stime=time.time()
    59         log.debug("Running wrapped plugin {}".format(self.__class__.__name__))
    60         if 'stderr' in kwargs:
    61             sys.stderr=kwargs['stderr']
     59        log.debug(u'Running wrapped plugin {}'.format(self.__class__.__name__))
     60        if u'stderr' in kwargs:
     61            sys.stderr=kwargs[u'stderr']
    6262        r=self.run(self,*args,**kwargs)
    6363        rtime=time.time()-stime
    64         log.info("Time running wrapped plugin {} = {}".format(self.__class__.__name__,rtime))
     64        log.info(u'Time running wrapped plugin {} = {}'.format(self.__class__.__name__,rtime))
    6565        return r
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/__init__.py

    r6399 r6450  
    33import os
    44import hwdetector.utils.log as log
    5 #log.debug("File "+__name__+" loaded")
     5#log.debug(u'File '+__name__+u' loaded')
    66import utils.PluginManager as PluginManager
    77from multiprocessing import Process,Pipe
     
    1515class HwDetector:
    1616    def __init__(self,*args,**kwargs):
    17         log.debug("HwDetector initialization: initiating plugin manager")
     17        log.debug(u'HwDetector initialization: initiating plugin manager')
    1818        self.pm = PluginManager()
    1919        self.all_plugins_are_needed = False
    20         os.path.dirname(os.path.abspath(__file__))+'/modules'
    21         log.debug("HwDetector initialization: adding path to plugin manager")
    22         self.pm.add_path( os.path.dirname(os.path.abspath(__file__))+'/modules',Detector)
     20        os.path.dirname(os.path.abspath(__file__))+u'/modules'
     21        log.debug(u'HwDetector initialization: adding path to plugin manager')
     22        self.pm.add_path( os.path.dirname(os.path.abspath(__file__))+u'/modules',Detector)
    2323        self.aborting = False
    2424        self.MAX_RUNNING_TIME = None
     
    3838    # def _close_stderr(self):
    3939    #     try:
    40     #         self.errfile=os.fdopen(2,'w',0)
     40    #         self.errfile=os.fdopen(2,u'w',0)
    4141    #         sys.stderr.close()
    42     #         sys.stderr = open(os.devnull, 'w')
     42    #         sys.stderr = open(os.devnull, u'w')
    4343    #     except:
    4444    #         pass
     
    6161                time.sleep(0.01)
    6262            self.nproc-=1
    63             log.debug('Killed {} remaning procs={}'.format(args[0].name,self.nproc))
     63            log.debug(u'Killed {} remaning procs={}'.format(args[0].name,self.nproc))
    6464        except Exception as e:
    65             log.warning('Error while killing {}'.format(args[0]))
     65            log.warning(u'Error while killing {}'.format(args[0]))
    6666        #self._open_stderr()
    6767
     
    7070            for k in sorted(self.capabilities.keys()):
    7171                if k in self.capabilities_stored:
    72                     if not k.startswith('HELPER'):
     72                    if not k.startswith(u'HELPER'):
    7373                        maxval=200
    74                         value=str(self.capabilities[k])
     74                        value=unicode(self.capabilities[k])
    7575                        if len(value) > maxval:
    76                             value=value[:maxval]+'.....'
    77                         print("{} = {}".format(k,value))
     76                            value=value[:maxval]+u'.....'
     77                        print(u'{} = {}'.format(k,value))
    7878
    7979    def _classify(self,*args,**kwargs):
     
    8484        self.all_provides = []
    8585
    86         if 'needs' in kwargs:
    87             run_needs=kwargs['needs']
     86        if u'needs' in kwargs:
     87            run_needs=kwargs[u'needs']
    8888            need_run_plugin=[]
    8989
     
    9898            class_needs = self.pm.classes[classname]._NEEDS
    9999
    100             log.debug('Class: {} needs {}'.format(classname,class_needs))
    101             log.debug('Class: {} provides {}'.format(classname,class_provides))
     100            log.debug(u'Class: {} needs {}'.format(classname,class_needs))
     101            log.debug(u'Class: {} provides {}'.format(classname,class_provides))
    102102
    103103            for x in class_provides:
    104104                if x not in self.mapping:
    105                     self.mapping[x]={'PROVIDED':[classname],'NEEDED':[]}
     105                    self.mapping[x]={u'PROVIDED':[classname],u'NEEDED':[]}
    106106                else:
    107                     self.mapping[x]['PROVIDED'].append(classname)
     107                    self.mapping[x][u'PROVIDED'].append(classname)
    108108            for x in class_needs:
    109109                if x not in self.mapping:
    110                     self.mapping[x]={'PROVIDED':[],'NEEDED':[classname]}
     110                    self.mapping[x]={u'PROVIDED':[],u'NEEDED':[classname]}
    111111                else:
    112                     self.mapping[x]['NEEDED'].append(classname)
    113 
    114             self.all_provides.extend(x for x in self.mapping if self.mapping[x]['PROVIDED'] and x not in self.all_provides)
    115             self.all_needs.extend(x for x in self.mapping if self.mapping[x]['NEEDED'] and x not in self.all_needs)
     112                    self.mapping[x][u'NEEDED'].append(classname)
     113
     114            self.all_provides.extend(x for x in self.mapping if self.mapping[x][u'PROVIDED'] and x not in self.all_provides)
     115            self.all_needs.extend(x for x in self.mapping if self.mapping[x][u'NEEDED'] and x not in self.all_needs)
    116116            #self.all_provides.extend([x for x in self.pm.classes[classname]._PROVIDES if x not in self.all_provides])
    117117            #self.all_needs.extend([x for x in self.pm.classes[classname]._NEEDS if x not in self.all_needs])
    118118
    119119            if class_provides == None or class_needs == None:
    120                 log.warning("Plugin {} with empty provides and needs, maybe it's using base class attributes !!! disabling plugin...".format(classname))
     120                log.warning(u'Plugin {} with empty provides and needs, maybe it\'s using base class attributes !!! disabling plugin...'.format(classname))
    121121                if self.all_plugins_are_needed:
    122                     log.error("Unable to continue, all plugins are needed to run properly")
     122                    log.error(u'Unable to continue, all plugins are needed to run properly')
    123123                    self.aborting = True
    124124                empty_provides.append(classname)
     
    126126            # Disable plugins that not provides nothing
    127127            if not class_provides:
    128                 log.warning("Plugin {} disabled because not providing anything!".format(classname))
     128                log.warning(u'Plugin {} disabled because not providing anything!'.format(classname))
    129129                if self.all_plugins_are_needed:
    130                     log.error("Unable to continue, all plugins are needed to run properly")
     130                    log.error(u'Unable to continue, all plugins are needed to run properly')
    131131                    self.aborting = True
    132132                empty_provides.append(classname)
     
    161161
    162162        if not_necessary:
    163             log.info('Provided {} not used by anybody'.format(','.join(not_necessary)))
     163            log.info(u'Provided {} not used by anybody'.format(u','.join(not_necessary)))
    164164
    165165        for i in empty_provides:
    166             log.warning("Disabling class {} not providing anything".format(i))
     166            log.warning(u'Disabling class {} not providing anything'.format(i))
    167167            if self.all_plugins_are_needed:
    168                 log.error("Unable to continue, all plugins are needed to run properly")
     168                log.error(u'Unable to continue, all plugins are needed to run properly')
    169169                self.aborting = True
    170170            del self.pm.classes[i]
    171171
    172172        for x in missing:
    173             log.error('Need {} not provided by any plugin'.format(x))
     173            log.error(u'Need {} not provided by any plugin'.format(x))
    174174            if self.all_plugins_are_needed:
    175                 log.error("Unable to continue, all plugins are needed to run properly")
     175                log.error(u'Unable to continue, all plugins are needed to run properly')
    176176                self.aborting = True
    177             for pl in self.mapping[x]['NEEDED']:
     177            for pl in self.mapping[x][u'NEEDED']:
    178178                if pl in self.pm.classes:
    179179                    del self.pm.classes[pl]
    180                     self.mapping[x]['NEEDED'].remove(pl)
     180                    self.mapping[x][u'NEEDED'].remove(pl)
    181181                    pending.remove(pl)
    182182
     
    256256                                        if x:
    257257                                            self.capabilities[x] = None
    258             log.debug('Endloop classifier')
     258            log.debug(u'Endloop classifier')
    259259
    260260            for r in to_remove:
     
    277277                    if not_found:
    278278                        if self.is_classified:
    279                             str='couldn\'t satisfy all dependencies for needed plugin'
     279                            str=u'couldn\'t satisfy all dependencies for needed plugin'
    280280                        else:
    281281                            if self.pm.found_duplicates:
    282                                 str='maybe missing dependency?'
     282                                str=u'maybe missing dependency?'
    283283                            else:
    284                                 str='maybe ciclic dependency?'
     284                                str=u'maybe ciclic dependency?'
    285285
    286286                            # Get plugins related to cycle
     
    291291                                        related.append(plug)
    292292
    293                             str+="\nPlugins related with cycle: {}".format(','.join(related))
    294 
    295                         log.error("Unable to continue, {} !!!\nNotFound providers for ({})".format(str,','.join(not_found)))
     293                            str+=u'\nPlugins related with cycle: {}'.format(u','.join(related))
     294
     295                        log.error(u'Unable to continue, {} !!!\nNotFound providers for ({})'.format(str,u','.join(not_found)))
    296296                        self.aborting = True
    297297                    else:
     
    303303                                    break
    304304                            if not add:
    305                                 log.error("Disabling class {} needed to run due to unresolved dependencies".format(pending_class))
     305                                log.error(u'Disabling class {} needed to run due to unresolved dependencies'.format(pending_class))
    306306                                self.aborting=True
    307307                                break
     
    310310                else:
    311311                    for pending_class in pending:
    312                         log.warning("Disabling class {} due to unresolved dependencies".format(pending_class))
     312                        log.warning(u'Disabling class {} due to unresolved dependencies'.format(pending_class))
    313313                        if self.all_plugins_are_needed:
    314                             log.error("Unable to continue, all plugins are needed to run properly")
     314                            log.error(u'Unable to continue, all plugins are needed to run properly')
    315315                            self.aborting = True
    316316                            break
     
    319319
    320320        self.MAX_PROCESSES = len(self.order)
    321         log.info("Plugin order calculated: {}".format(','.join(self.order)))
     321        log.info(u'Plugin order calculated: {}'.format(u','.join(self.order)))
    322322        self.is_classified = True
    323323        if self.aborting:
     
    332332                ret=False
    333333        else:
    334             log.info("Running all plugins")
     334            log.info(u'Running all plugins')
    335335
    336336        if not self.START_RUNNING_TIME:
     
    365365                    if can_start:
    366366                        pipe_in, pipe_out = Pipe(duplex=False)
    367                         #kw = {'out': pipe_out,'stderr':open(os.devnull,'w')}
    368                         kw = {'out': pipe_out}
     367                        #kw = {u'out': pipe_out,u'stderr':open(os.devnull,u'w')}
     368                        kw = {u'out': pipe_out}
    369369                        args = (pipe_out,)
    370370                        obj = self.pm.classes[plug]()
     
    372372                        for need in obj._NEEDS:
    373373                            if need and need in self.capabilities.keys():
    374                                 if need.lower()[0:6] == 'helper':
     374                                if need.lower()[0:6] == u'helper':
    375375                                    f=pickle.loads(self.helpers[need])
    376                                     dummy_func=types.FunctionType(f['code'].__code__,f['glob'],f['code'].__code__.co_name)
    377                                     dummy_func.func_globals.update({'self':f['code'].im_self})
    378                                     obj.__dict__[f['code'].__code__.co_name]=dummy_func
    379                                     setattr(obj,f['code'].__code__.co_name,f['code'])
    380                                     log.debug('Helper {} registered into {}'.format(need,obj.__class__.__name__))
     376                                    dummy_func=types.FunctionType(f[u'code'].__code__,f[u'glob'],f[u'code'].__code__.co_name)
     377                                    dummy_func.func_globals.update({u'self':f[u'code'].im_self})
     378                                    obj.__dict__[f[u'code'].__code__.co_name]=dummy_func
     379                                    setattr(obj,f[u'code'].__code__.co_name,f[u'code'])
     380                                    log.debug(u'Helper {} registered into {}'.format(need,obj.__class__.__name__))
    381381                                else:
    382382                                    if self.capabilities[need] == None:
    383                                         log.warning('Providing capability {} with an empty value to {} plugin'.format(need,obj.__class__.__name__))
     383                                        log.warning(u'Providing capability {} with an empty value to {} plugin'.format(need,obj.__class__.__name__))
    384384                                    kw.update({need:self.capabilities[need]})
    385385                                    args = args + (self.capabilities[need],)
    386386
    387                         procs[self.order.index(plug)] = {'process':Process(target=obj._run,name=plug,args=args,kwargs=kw),
    388                                                         'name':plug,
    389                                                         'stime':None,
    390                                                         'rtime':None,
    391                                                         'pin':pipe_in,
    392                                                         'pout':pipe_out}
     387                        procs[self.order.index(plug)] = {u'process':Process(target=obj._run,name=plug,args=args,kwargs=kw),
     388                                                        u'name':plug,
     389                                                        u'stime':None,
     390                                                        u'rtime':None,
     391                                                        u'pin':pipe_in,
     392                                                        u'pout':pipe_out}
    393393                        if not self.aborting:
    394                             procs[self.order.index(plug)]['process'].start()
    395                             procs[self.order.index(plug)]['stime'] = time.time()
     394                            procs[self.order.index(plug)][u'process'].start()
     395                            procs[self.order.index(plug)][u'stime'] = time.time()
    396396                            started.append(plug)
    397397                            self.nproc += 1
    398398                            self.nproc_started +=1
    399                             log.debug("Started process number={} ({})".format(self.nproc_started,plug))
     399                            log.debug(u'Started process number={} ({})'.format(self.nproc_started,plug))
    400400
    401401            # check processes
     
    403403                if done == False:   # recalculation in progress
    404404                    break
    405                 if pinfo and pinfo['stime']:
    406                     t = time.time() - pinfo['stime']
    407                     if self.MAX_RUNNING_TIME and t > self.MAX_RUNNING_TIME and not pinfo['rtime']:
    408                         self._kill_proc(pinfo['process'])
    409                         pinfo['rtime']=t
    410                         log.error("Plugin {} aborted, maximun running time ({}) exceded".format(pinfo['name'],self.MAX_RUNNING_TIME))
     405                if pinfo and pinfo[u'stime']:
     406                    t = time.time() - pinfo[u'stime']
     407                    if self.MAX_RUNNING_TIME and t > self.MAX_RUNNING_TIME and not pinfo[u'rtime']:
     408                        self._kill_proc(pinfo[u'process'])
     409                        pinfo[u'rtime']=t
     410                        log.error(u'Plugin {} aborted, maximun running time ({}) exceded'.format(pinfo[u'name'],self.MAX_RUNNING_TIME))
    411411                        if self.all_plugins_are_needed:
    412                             log.error("Unable to continue, all plugins are needed to run properly")
     412                            log.error(u'Unable to continue, all plugins are needed to run properly')
    413413                            self.aborting = True
    414                         del self.pm.classes[pinfo['name']]
    415                         log.debug("Plugin {} deactivated, recalculating dependencies & rerunning".format(pinfo['name']))
     414                        del self.pm.classes[pinfo[u'name']]
     415                        log.debug(u'Plugin {} deactivated, recalculating dependencies & rerunning'.format(pinfo[u'name']))
    416416                        done = False
    417417                        ret = False
    418418                        break
    419                     if pinfo['pin'].poll():
    420                         pinfo['rtime']=t
    421                         output = pinfo['pin'].recv()
    422                         pinfo['process'].join()
     419                    if pinfo[u'pin'].poll():
     420                        pinfo[u'rtime']=t
     421                        output = pinfo[u'pin'].recv()
     422                        pinfo[u'process'].join()
    423423                        self.nproc -= 1
    424                         log.debug('Finished {}'.format(pinfo['name']))
    425                         for provide in self.pm.classes[pinfo['name']]._PROVIDES:
     424                        log.debug(u'Finished {}'.format(pinfo[u'name']))
     425                        for provide in self.pm.classes[pinfo[u'name']]._PROVIDES:
    426426                            if provide:
    427427                                if output and type(output) == type(dict()) and provide in output.keys():
    428                                     #out_stripped=str(output[provide]).upper().replace('NULL','null').strip()
     428                                    #out_stripped=str(output[provide]).upper().replace(u'NULL',u'null').strip()
    429429                                    out_stripped = output[provide]
    430                                     if provide[0:6].lower()=='helper':
     430                                    if provide[0:6].lower()==u'helper':
    431431                                        self.helpers[provide] = out_stripped
    432                                         out_stripped = 'STORED'
     432                                        out_stripped = u'STORED'
    433433                                    if provide in self.capabilities.keys() and self.capabilities[provide] != None:
    434                                         log.warning("Plugin {} overwrite {} capability".format(pinfo['name'], provide))
     434                                        log.warning(u'Plugin {} overwrite {} capability'.format(pinfo[u'name'], provide))
    435435                                    else:
    436                                         log.debug("Plugin {} set the capability '{}' with value '{}' in {}".format( pinfo['name'],
     436                                        log.debug(u'Plugin {} set the capability \'{}\' with value \'{}\' in {}'.format( pinfo[u'name'],
    437437                                                                                                                provide,
    438438                                                                                                                out_stripped,
    439                                                                                                                 pinfo['rtime']))
     439                                                                                                                pinfo[u'rtime']))
    440440                                    if out_stripped == None:
    441                                         log.warning("Capability {} was stored with and empty value of {}".format(provide,str(out_stripped)))
     441                                        log.warning(u'Capability {} was stored with and empty value of {}'.format(provide,str(out_stripped)))
    442442                                    self.capabilities[provide] = out_stripped
    443443                                    self.capabilities_stored.append(provide)
     
    445445                                    if provide in self.capabilities_stored:
    446446                                        log.info(
    447                                             "Plugin {} was provided by unknown instead of {}, recalculate not needed".format(
    448                                                 provide,pinfo['name']))
     447                                            u'Plugin {} was provided by unknown instead of {}, recalculate not needed'.format(
     448                                                provide,pinfo[u'name']))
    449449                                    else:
    450                                         log.error("Plugin {} mus't provide {} which wasn't available into result".format(
    451                                             pinfo['name'], provide))
     450                                        log.error(u'Plugin {} mus\'t provide {} which wasn\'t available into result'.format(
     451                                            pinfo[u'name'], provide))
    452452                                        if self.all_plugins_are_needed:
    453                                             log.error("Unable to continue, all plugins are needed to run properly")
     453                                            log.error(u'Unable to continue, all plugins are needed to run properly')
    454454                                            self.aborting = True
    455                                         del self.pm.classes[pinfo['name']]
    456                                         log.debug("Plugin {} deactivated, recalculating dependencies & rerunning".format(pinfo['name']))
     455                                        del self.pm.classes[pinfo[u'name']]
     456                                        log.debug(u'Plugin {} deactivated, recalculating dependencies & rerunning'.format(pinfo[u'name']))
    457457                                        done = False
    458458                                        ret = False
    459459                                        break
    460                         remaning.remove(pinfo['name'])
    461 
    462                     elif not pinfo['rtime'] and not pinfo['process'].is_alive():
    463                         log.error("Plugin {} dead without sending results".format(pinfo['name']))
     460                        remaning.remove(pinfo[u'name'])
     461
     462                    elif not pinfo[u'rtime'] and not pinfo[u'process'].is_alive():
     463                        log.error(u'Plugin {} dead without sending results'.format(pinfo[u'name']))
    464464                        if self.all_plugins_are_needed:
    465                             log.error("Unable to continue, all plugins are needed to run properly")
     465                            log.error(u'Unable to continue, all plugins are needed to run properly')
    466466                            self.aborting = True
    467467                        self.nproc-=1
    468                         del self.pm.classes[pinfo['name']]
    469                         log.debug("Plugin {} deactivated, recalculating dependencies & rerunning".format(pinfo['name']))
     468                        del self.pm.classes[pinfo[u'name']]
     469                        log.debug(u'Plugin {} deactivated, recalculating dependencies & rerunning'.format(pinfo[u'name']))
    470470                        done = False
    471471                        ret = False
     
    473473                    if done == False or self.aborting:
    474474                        for pinfo2 in procs:
    475                             if pinfo2 and pinfo2['stime'] and pinfo2['process'].is_alive():
    476                                 self._kill_proc(pinfo2['process'])
    477                                 pinfo2['rtime'] = t
     475                            if pinfo2 and pinfo2[u'stime'] and pinfo2[u'process'].is_alive():
     476                                self._kill_proc(pinfo2[u'process'])
     477                                pinfo2[u'rtime'] = t
    478478                                if self.aborting:
    479479                                    log.debug(
    480                                         "Aborting... terminating process {}".format(pinfo2['name']))
     480                                        u'Aborting... terminating process {}'.format(pinfo2[u'name']))
    481481                                else:
    482                                     log.debug("Terminating process {} due recalculation in process".format(pinfo2['name']))
     482                                    log.debug(u'Terminating process {} due recalculation in process'.format(pinfo2[u'name']))
    483483
    484484
     
    486486                if len(remaning) > 0:
    487487                    still = [ p for p in remaning if p in started ]
    488                     log.debug('Endloop plugins still running: {}'.format(','.join(still)))
     488                    log.debug(u'Endloop plugins still running: {}'.format(u','.join(still)))
    489489                else:
    490                     log.debug('No more plugins to run!')
     490                    log.debug(u'No more plugins to run!')
    491491                #check all finished (done=True) or wait to next round for start & check (done=None)
    492492                done = True
    493493                for pinfo in procs:
    494                     if not pinfo or pinfo['rtime'] == None:
     494                    if not pinfo or pinfo[u'rtime'] == None:
    495495                        done = None
    496496                        timesleep=0.01
     
    503503            # kill all plugins currently running
    504504            for p in procs:
    505                 if p and p['stime'] and p['process'].is_alive():
    506                     self._kill_proc(p['process'])
    507                     p['rtime'] = t
    508                     log.debug("Terminating process {} before recalculation in process".format(p['name']))
     505                if p and p[u'stime'] and p[u'process'].is_alive():
     506                    self._kill_proc(p[u'process'])
     507                    p[u'rtime'] = t
     508                    log.debug(u'Terminating process {} before recalculation in process'.format(p[u'name']))
    509509            if not self.aborting:
    510510                self._classify(**kwargs)
     
    516516                for i in range(0,len(procs)):
    517517                    #if procs[i] == None:
    518                     if not (procs[i] and procs[i]['rtime']):
    519                         log.error("Plugin {} can't be started, previous plugin fail providing dependencies".format(self.order[i]))
     518                    if not (procs[i] and procs[i][u'rtime']):
     519                        log.error(u'Plugin {} can\'t be started, previous plugin fail providing dependencies'.format(self.order[i]))
    520520                        if self.all_plugins_are_needed:
    521                             log.error("Unable to continue, all plugins are needed to run properly")
     521                            log.error(u'Unable to continue, all plugins are needed to run properly')
    522522                            self.aborting = True
    523523                        ret = False
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxhelpers.py

    r6429 r6450  
    99import base64,zlib
    1010
    11 log.debug("File "+__name__+" loaded")
     11log.debug(u'File '+__name__+u' loaded')
    1212
    1313class LlxHelpers(Detector):
    14     _PROVIDES = ['HELPER_EXECUTE','HELPER_UNCOMMENT',"HELPER_GET_FILE_FROM_NET",'HELPER_FILE_FIND_LINE','HELPER_DEMOTE','HELPER_SET_ROOT_IDS','HELPER_CHECK_ROOT','HELPER_WHO_I_AM','HELPER_USERS_LOGGED','ROOT_MODE','HELPER_COMPRESS_FILE','HELPER_LIST_FILES','HELPER_COMPACT_FILES']
     14    _PROVIDES = [u'HELPER_EXECUTE',u'HELPER_UNCOMMENT',u'HELPER_GET_FILE_FROM_NET',u'HELPER_FILE_FIND_LINE',u'HELPER_DEMOTE',u'HELPER_SET_ROOT_IDS',u'HELPER_CHECK_ROOT',u'HELPER_WHO_I_AM',u'HELPER_USERS_LOGGED',u'ROOT_MODE',u'HELPER_COMPRESS_FILE',u'HELPER_LIST_FILES',u'HELPER_COMPACT_FILES']
    1515    _NEEDS = []
    1616
    1717    # def _close_stderr(self):
    18     #     self.errfile=os.fdopen(2,'w',0)
     18    #     self.errfile=os.fdopen(2,u'w',0)
    1919    #     sys.stderr.close()
    20     #     sys.stderr = open(os.devnull, 'w')
     20    #     sys.stderr = open(os.devnull, u'w')
    2121    #
    2222    #
     
    2828    # def ctl_stderr(self,*args,**kwargs):
    2929    #     keys=[k.lower() for k in kwargs.keys()]
    30     #     if 'close' in keys:
     30    #     if u'close' in keys:
    3131    #         self._close_stderr()
    32     #     if 'open' in keys:
     32    #     if u'open' in keys:
    3333    #         self._open_stderr()
    3434
    3535    def uncomment(self,*args,**kwargs):
    36         r = ''
    37         comments=kwargs.get('comments',['#'])
     36        r = u''
     37        comments=kwargs.get(u'comments',[u'#'])
    3838        creg=[]
    3939        for c in comments:
    40             creg.append(c+'.*')
    41         creg='|'.join(creg)
     40            creg.append(c+u'.*')
     41        creg=u'|'.join(creg)
    4242        try:
    4343            is_file = os.path.isfile(args[0])
     
    4545            is_file = False
    4646        if is_file:
    47             reg=re.compile(r'^(\s*|{})*$'.format(creg))
    48             try:
    49                 with open(args[0],'r') as f:
     47            reg=re.compile(r'^(\s*|{})*$'.format(creg),re.UNICODE)
     48            try:
     49                with open(args[0],u'r') as f:
    5050                    for line in f.readlines():
     51                        line=line.decode('utf-8')
    5152                        m=re.match(reg,line)
    5253                        if not m:
    5354                            r += line
    54             except:
    55                 log.warning('Trying to read unreadable file {}'.format(args[0]))
    56                 r += 'NOT_READABLE'
     55            except Exception as e:
     56                log.warning(u'Trying to read unreadable file {}'.format(args[0]))
     57                r += unicode(u'NOT_READABLE')
     58
    5759
    5860        else:
    5961            if isinstance(args[0],list):
    60                 string = ''.join(str(args[0]))
    61             else:
    62                 string=str(args[0])
     62                string = u''.join(str(args[0]))
     63            else:
     64                string=unicode(args[0])
    6365
    6466            reg=re.compile(r'^(\s*|#.*)*$')
    65             for line in string.split("\n"):
     67            for line in string.split(u'\n'):
    6668                m=re.match(reg,line)
    6769                if not m:
    68                     r += line + "\n"
    69         try:
    70             r=r.decode('utf-8')
    71         except UnicodeDecodeError:
    72             r=r.encode('utf-8')
     70                    r += line + u'\n'
     71        try:
     72            r=r.decode(u'utf-8')
     73        except:
     74            r=r.encode(u'utf-8').decode(u'utf-8')
    7375        return r.strip()
    7476
     
    7678        if not args[0]:
    7779            return None
    78         if kwargs.get('proxy',None):
    79         #if 'proxy' in kwargs and kwargs['proxy'] == True:
     80        if kwargs.get(u'proxy',None):
     81        #if u'proxy' in kwargs and kwargs[u'proxy'] == True:
    8082            proxy = urllib.ProxyHandler() #use autodetected proxies
    8183            proxydata={}
    82             if kwargs.get('proxy_http',None):
    83                 proxydata.setdefault('http',kwargs.get(kwargs.get('proxy_http')))
    84             if kwargs.get('proxy_https',None):
    85                 proxydata.setdefault('https',kwargs.get(kwargs.get('proxy_https')))
     84            if kwargs.get(u'proxy_http',None):
     85                proxydata.setdefault(u'http',kwargs.get(kwargs.get(u'proxy_http')))
     86            if kwargs.get(u'proxy_https',None):
     87                proxydata.setdefault(u'https',kwargs.get(kwargs.get(u'proxy_https')))
    8688
    8789            if proxydata:
     
    9193            urllib.install_opener(opener)
    9294
    93         proto=args[0].split(':')
     95        proto=args[0].split(u':')
    9496        if proto[0]:
    9597            proto=proto[0].lower()
    9698        else:
    9799            return None
    98         if 'http' != proto and 'https' != proto:
     100        if u'http' != proto and u'https' != proto:
    99101            return None
    100102        try:
     
    102104            data = content.read()
    103105            try:
    104                 data=data.decode('utf-8')
     106                data=data.decode(u'utf-8')
    105107            except UnicodeDecodeError:
    106                 data=data.encode('utf-8')
     108                data=data.encode(u'utf-8')
    107109            return data
    108110        except Exception as e:
     
    128130        if not is_file:
    129131            if not isinstance(content,list):
    130                 s = content.split("\n")
     132                s = content.split(u'\n')
    131133            else:
    132134                s = content
    133135        else:
    134             with open(content,'r') as f:
     136            with open(content,u'r') as f:
    135137                s=f.readlines()
    136138
    137139        if not multimatch:
    138             r=re.compile('\s*'.join(keys),re.IGNORECASE | re.UNICODE)
     140            r=re.compile(u'\s*'.join(keys),re.IGNORECASE | re.UNICODE)
    139141        else:
    140142            r=[]
    141143            for k in keys:
    142                 r.append(re.compile('\s*'.join(k),re.IGNORECASE | re.UNICODE))
     144                r.append(re.compile(u'\s*'.join(k),re.IGNORECASE | re.UNICODE))
    143145        i=0
    144146        output = []
     
    147149                m=re.findall(r,line)
    148150                if m:
    149                     if kwargs.get('multiple_result',False):
     151                    if kwargs.get(u'multiple_result',False):
    150152                        output.append(m)
    151153                    else:
     
    157159                    output.append(m[0])
    158160                if i == len(r):
    159                     if kwargs.get('multiple_result',False):
     161                    if kwargs.get(u'multiple_result',False):
    160162                        output.append(m[0])
    161163                    else:
     
    166168    def demote(self,*args,**kwargs):
    167169        try:
    168             info=pwd.getpwnam('nobody')
     170            info=pwd.getpwnam(u'nobody')
    169171            id=info.pw_uid
    170172            gid=info.pw_gid
     
    192194        user_name=user_info[0]
    193195        groups = [group[0] for group in grp.getgrall() if user_name in group[3]]
    194         return {'id':euid,'user_info':user_info,'name':user_name,'groups':groups}
     196        return {u'id':euid,u'user_info':user_info,u'name':user_name,u'groups':groups}
    195197
    196198    def users_logged(self,*args,**kwargs):
    197199        l=[]
    198200        regexp=re.compile(r'^(?P<username>\S+)\s+(?P<terminal>\S+)\s+\S+\s+\S+\s+(?P<display>\S+)?$')
    199         for line in self.execute(run='who').split('\n'):
     201        for line in self.execute(run=u'who').split(u'\n'):
    200202            m = re.match(regexp,line)
    201203            if m:
    202204                d=m.groupdict()
    203                 if d['display'] != None and d['username'] not in l:
    204                     l.append(d['username'])
     205                if d[u'display'] != None and d[u'username'] not in l:
     206                    l.append(d[u'username'])
    205207        return l
    206208
    207209    def execute(self,timeout=3.0,shell=False,*args,**kwargs):
    208210        params={}
    209         if 'run' not in kwargs:
    210             log.error('Execute called without \'run\' key parameter')
    211             return None
    212         else:
    213             if not isinstance(kwargs['run'],list):
    214                 runlist=kwargs['run'].split(' ')
    215             else:
    216                 runlist=kwargs['run']
     211        if u'run' not in kwargs:
     212            log.error(u'Execute called without \'run\' key parameter')
     213            return None
     214        else:
     215            if not isinstance(kwargs[u'run'],list):
     216                runlist=kwargs[u'run'].split(u' ')
     217            else:
     218                runlist=kwargs[u'run']
    217219        timeout_remaning=float(timeout)
    218220        #Ready for python3
    219         #params.setdefault('timeout',int(timeout))
     221        #params.setdefault(u'timeout',int(timeout))
    220222        #Python 2 code
    221223        delay=0.1
    222         if 'stderr' in kwargs:
    223             if kwargs['stderr'] == 'stdout':
    224                 params.setdefault('stderr',subprocess.STDOUT)
    225             if kwargs['stderr'] == None or kwargs['stderr'] == 'no':
    226                 params.setdefault('stderr',open(os.devnull,'w'))
    227             else:
    228                 params.setdefault('stderr',subprocess.PIPE)
    229         else:
    230             params.setdefault('stderr',subprocess.PIPE)
    231         params.setdefault('stdout',subprocess.PIPE)
     224        if u'stderr' in kwargs:
     225            if kwargs[u'stderr'] == u'stdout':
     226                params.setdefault(u'stderr',subprocess.STDOUT)
     227            if kwargs[u'stderr'] == None or kwargs[u'stderr'] == u'no':
     228                params.setdefault(u'stderr',open(os.devnull,u'w'))
     229            else:
     230                params.setdefault(u'stderr',subprocess.PIPE)
     231        else:
     232            params.setdefault(u'stderr',subprocess.PIPE)
     233        params.setdefault(u'stdout',subprocess.PIPE)
    232234        with_uncomment=False
    233         if 'nocomment' in kwargs:
    234             if kwargs['nocomment'] == True or kwargs['nocomment'] == 'yes':
     235        if u'nocomment' in kwargs:
     236            if kwargs[u'nocomment'] == True or kwargs[u'nocomment'] == u'yes':
    235237                with_uncomment=True
    236238
     
    240242        root_mode = False
    241243        if self.check_root():
    242             if 'asroot' in kwargs:
    243                 if kwargs['asroot'] == True or kwargs['asroot'] == 'yes':
     244            if u'asroot' in kwargs:
     245                if kwargs[u'asroot'] == True or kwargs[u'asroot'] == u'yes':
    244246                    root_mode=True
    245247            if not root_mode:
    246                 params.setdefault('preexec_fn', self.demote)
    247                 user = 'nobody'
    248                 group = 'nogroup'
    249             else:
    250                 params.setdefault('preexec_fn', self.set_root_ids)
    251 
    252         params.setdefault('shell',shell)
     248                params.setdefault(u'preexec_fn', self.demote)
     249                user = u'nobody'
     250                group = u'nogroup'
     251            else:
     252                params.setdefault(u'preexec_fn', self.set_root_ids)
     253
     254        params.setdefault(u'shell',shell)
    253255        stdout=None
    254256        stderr=None
    255         log.info('Executing command \'{}\' as {}:{}'.format(' '.join(runlist),user,group))
     257        log.info(u'Executing command \'{}\' as {}:{}'.format(u' '.join(runlist),user,group))
    256258        try:
    257259            start=time.time()
     
    266268                stdout,stderr = p.communicate()
    267269            if timeout_remaning <= 0:
    268                 raise Exception('timeout({}) exceded while executing {}'.format(timeout,kwargs['run']))
     270                raise Exception(u'timeout({}) exceded while executing {}'.format(timeout,kwargs[u'run']))
    269271            if ret != 0:
    270                 if stderr != '':
    271                     stderr = 'stderr={}'.format(stderr)
    272                 log.warning('Execution with exit code {} (possible error) {}'.format(ret,stderr))
     272                if stderr != u'':
     273                    stderr = u'stderr={}'.format(stderr)
     274                log.warning(u'Execution with exit code {} (possible error) {}'.format(ret,stderr))
    273275        except Exception as e:
    274             log.error('Error executing: {}'.format(e))
     276            log.error(u'Error executing: {}'.format(e))
    275277            return None
    276278        if stdout != None:
     
    280282                out=stdout.strip()
    281283            try:
    282                 out=out.decode('utf-8')
     284                out=out.decode(u'utf-8')
    283285            except UnicodeDecodeError:
    284                 out=out.encode('utf-8')
     286                out=out.encode(u'utf-8')
    285287            return out
    286288        else:
    287             log.error("Execution of {} hasn't produced any result, returning None".format(kwargs['run']))
     289            log.error(u'Execution of {} hasn\'t produced any result, returning None'.format(kwargs['run']))
    288290            return None
    289291
    290292    def compress_file(self,*args,**kwargs):
    291         file=kwargs.get('file')
    292         string=kwargs.get('string')
    293         if not ('file' in kwargs or  'string' in kwargs):
    294             log.error('Compressing called without \'file\' or \'string\' keyparam')
     293        file=kwargs.get(u'file')
     294        string=kwargs.get(u'string')
     295        if not (u'file' in kwargs or  u'string' in kwargs):
     296            log.error(u'Compressing called without \'file\' or \'string\' keyparam')
    295297        if file:
    296298            if os.path.exists(file):
    297299                try:
    298                     with open(file,'r') as f:
     300                    with open(file,u'r') as f:
    299301                        try:
    300302                            content=f.read()
     
    302304                            return None
    303305                        try:
    304                             return ('__gz__',base64.b64encode(zlib.compress(content.encode('utf-8').strip())))
     306                            return (u'__gz__',base64.b64encode(zlib.compress(content.encode(u'utf-8').strip())))
    305307                        except:
    306                             return ('__gz__',base64.b64encode(zlib.compress(content.strip())))
     308                            return (u'__gz__',base64.b64encode(zlib.compress(content.strip())))
    307309                except Exception as e:
    308                     log.warning('Fail compressing file {} : {}'.format(file,e))
    309                     return None
     310                    log.warning(u'Fail compressing file {} : {}'.format(file,str(e).decode('utf-8')))
     311                    return unicode(u'NOT_READABLE')
    310312        if string:
    311313            try:
    312314                try:
    313                     return ('__gz__',base64.b64encode(zlib.compress(string.encode('utf-8').strip())))
     315                    return (u'__gz__',base64.b64encode(zlib.compress(string.encode(u'utf-8').strip())))
    314316                except:
    315                     return ('__gz__',base64.b64encode(zlib.compress(string.strip())))
     317                    return (u'__gz__',base64.b64encode(zlib.compress(string.strip())))
    316318            except Exception as e:
    317                 log.warning('Fail compressing string {} : {}'.format(string,e))
     319                log.warning(u'Fail compressing string {} : {}'.format(string,e))
    318320                return None
    319321
    320322
    321323    def list_files(self,*args,**kwargs):
    322         path=kwargs.get('path',None)
    323         filter=kwargs.get('filter',None)
    324         regexp=kwargs.get('regexp',None)
     324        path=kwargs.get(u'path',None)
     325        filter=kwargs.get(u'filter',None)
     326        regexp=kwargs.get(u'regexp',None)
    325327
    326328        if not path:
    327             log.error('List files called without \'path\' keyparameter')
     329            log.error(u'List files called without \'path\' keyparameter')
    328330            return None
    329331
     
    366368        if not (files and isinstance(files,list)):
    367369            return None
    368         content=''
     370        content=u''
    369371        for file in files:
    370372            try:
    371                 with open(file,'r') as f:
     373                with open(file,u'r') as f:
    372374                    content+=f.read()
    373375            except Exception as e:
     
    378380    def run(self,*args,**kwargs):
    379381        return {
    380             'ROOT_MODE': self.check_root(),
    381             'HELPER_UNCOMMENT':{'code':self.uncomment,'glob':globals()},
    382             'HELPER_GET_FILE_FROM_NET': {'code': self.get_file_from_net, 'glob': globals()},
    383             'HELPER_FILE_FIND_LINE':{'code': self.file_find_line, 'glob': globals()},
    384             'HELPER_DEMOTE':{'code':self.demote,'glob':globals()},
    385             'HELPER_SET_ROOT_IDS':{'code':self.set_root_ids,'glob':globals()},
    386             'HELPER_CHECK_ROOT':{'code':self.check_root,'glob':globals()},
    387             'HELPER_WHO_I_AM':{'code':self.who_i_am,'glob':globals()},
    388             'HELPER_EXECUTE':{'code':self.execute,'glob':globals()},
    389             'HELPER_USERS_LOGGED':{'code':self.users_logged,'glob':globals()},
    390             'HELPER_COMPRESS_FILE':{'code':self.compress_file,'glob':globals()},
    391             'HELPER_COMPACT_FILES':{'code':self.compact_files,'glob':globals()},
    392             'HELPER_LIST_FILES':{'code':self.list_files,'glob':globals()}
     382            u'ROOT_MODE': self.check_root(),
     383            u'HELPER_UNCOMMENT':{u'code':self.uncomment,u'glob':globals()},
     384            u'HELPER_GET_FILE_FROM_NET': {u'code': self.get_file_from_net, u'glob': globals()},
     385            u'HELPER_FILE_FIND_LINE':{u'code': self.file_find_line, u'glob': globals()},
     386            u'HELPER_DEMOTE':{u'code':self.demote,u'glob':globals()},
     387            u'HELPER_SET_ROOT_IDS':{u'code':self.set_root_ids,u'glob':globals()},
     388            u'HELPER_CHECK_ROOT':{u'code':self.check_root,u'glob':globals()},
     389            u'HELPER_WHO_I_AM':{u'code':self.who_i_am,u'glob':globals()},
     390            u'HELPER_EXECUTE':{u'code':self.execute,u'glob':globals()},
     391            u'HELPER_USERS_LOGGED':{u'code':self.users_logged,u'glob':globals()},
     392            u'HELPER_COMPRESS_FILE':{u'code':self.compress_file,u'glob':globals()},
     393            u'HELPER_COMPACT_FILES':{u'code':self.compact_files,u'glob':globals()},
     394            u'HELPER_LIST_FILES':{u'code':self.list_files,u'glob':globals()}
    393395                }
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxinitialization.py

    r6399 r6450  
    33import hwdetector.utils.log as log
    44
    5 log.debug("File "+__name__+" loaded")
     5log.debug(u'File '+__name__+u' loaded')
    66
    77class LlxInitialization(Detector):
    8     _NEEDS = ['HELPER_UNCOMMENT','LDAP_MODE','HELPER_FILE_FIND_LINE','N4D_VARS']
    9     _PROVIDES = ['HOSTNAME','INTERNAL_INTERFACE','EXTERNAL_INTERFACE','NFS_INITIALIZATION']
     8    _NEEDS = [u'HELPER_UNCOMMENT',u'LDAP_MODE',u'HELPER_FILE_FIND_LINE',u'N4D_VARS']
     9    _PROVIDES = [u'HOSTNAME',u'INTERNAL_INTERFACE',u'EXTERNAL_INTERFACE',u'NFS_INITIALIZATION']
    1010
    1111
     
    1414        output = {}
    1515        ssync_from = None
    16         n4d_vars=kwargs['N4D_VARS']
    17         output.update({'HOSTNAME':self.uncomment('/etc/hostname')})
    18         mapping={'INTERNAL_INTERFACE':'INTERNAL_INTERFACE','EXTERNAL_INTERFACE':'EXTERNAL_INTERFACE'}
     16        n4d_vars=kwargs[u'N4D_VARS']
     17        output.update({u'HOSTNAME':self.uncomment(u'/etc/hostname')})
     18        mapping={u'INTERNAL_INTERFACE':u'INTERNAL_INTERFACE',u'EXTERNAL_INTERFACE':u'EXTERNAL_INTERFACE'}
    1919        for search_var in mapping:
    20             if search_var in n4d_vars and 'value' in n4d_vars[search_var]:
    21                 output.update({mapping[search_var]:n4d_vars[search_var]['value']})
     20            if search_var in n4d_vars and u'value' in n4d_vars[search_var]:
     21                output.update({mapping[search_var]:n4d_vars[search_var][u'value']})
    2222            else:
    2323                output.update({mapping[search_var]:None})
    24         line=self.file_find_line(r'/lib/systemd/system/net-server\x2dsync.mount',r'What = (\d+(?:\.\d+){3}):/net/server-sync')
     24        line=self.file_find_line(r'/lib/systemd/system/net-server\x2dsync.mountu',r'What = (\d+(?:\.\d+){3}):/net/server-sync')
    2525        if line:
    26             ssync_from=''.join(line)
     26            ssync_from=u''.join(line)
    2727        else:
    2828            ssync_from=None
    29         output.update({'NFS_INITIALIZATION':ssync_from})
     29        output.update({u'NFS_INITIALIZATION':ssync_from})
    3030
    3131        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxldap.py

    r6420 r6450  
    77import os
    88
    9 log.debug("File "+__name__+" loaded")
     9log.debug(u'File '+__name__+u' loaded')
    1010
    1111class LlxLdap(Detector):
    12     _NEEDS = ['HELPER_EXECUTE','HELPER_FILE_FIND_LINE','HELPER_UNCOMMENT','HELPER_CHECK_OPEN_PORT','LLIUREX_RELEASE','HELPER_CHECK_ROOT','NETINFO','N4D_VARS','HELPER_CHECK_NS','HELPER_COMPRESS_FILE']
    13     _PROVIDES = ['SERVER_LDAP','LDAP_INFO','LDAP_MODE','LDAP_MASTER_IP','LOCAL_LDAP']
     12    _NEEDS = [u'HELPER_EXECUTE',u'HELPER_FILE_FIND_LINE',u'HELPER_UNCOMMENT',u'HELPER_CHECK_OPEN_PORT',u'LLIUREX_RELEASE',u'HELPER_CHECK_ROOT',u'NETINFO',u'N4D_VARS',u'HELPER_CHECK_NS',u'HELPER_COMPRESS_FILE']
     13    _PROVIDES = [u'SERVER_LDAP',u'LDAP_INFO',u'LDAP_MODE',u'LDAP_MASTER_IP',u'LOCAL_LDAP']
    1414
    1515    def check_files(self,*args,**kwargs):
     
    1919
    2020        if not server:
    21             log.error('Unable to locate ldap server')
    22 
    23         if mode and mode.lower() == 'independent':
     21            log.error(u'Unable to locate ldap server')
     22
     23        if mode and mode.lower() == u'independent':
    2424            servername = server
    2525        else:
    26             servername = 'localhost'
     26            servername = u'localhost'
    2727
    2828        output={}
    29         content_ldap_conf=self.uncomment("/etc/ldap.conf")
     29        content_ldap_conf=self.uncomment(u'/etc/ldap.conf')
    3030        ldap_conf_ok = self.file_find_line(content_ldap_conf,
    3131        [
    32             ['^base','dc=ma5,dc=lliurex,dc=net'],
    33             ['^uri','ldap://'+servername],
    34             ['^nss_base_group','ou=Groups,dc=ma5,dc=lliurex,dc=net'],
    35             ['^nss_map_attribute','gecos','description']
     32            [u'^base',u'dc=ma5,dc=lliurex,dc=net'],
     33            [u'^uri',u'ldap://'+servername],
     34            [u'^nss_base_group',u'ou=Groups,dc=ma5,dc=lliurex,dc=net'],
     35            [u'^nss_map_attribute',u'gecos',u'description']
    3636        ])
    37         content_etc_ldap_ldap_conf=self.uncomment("/etc/ldap/ldap.conf")
     37        content_etc_ldap_ldap_conf=self.uncomment(u'/etc/ldap/ldap.conf')
    3838        etc_ldap_ldap_conf_ok = self.file_find_line(content_etc_ldap_ldap_conf,
    3939        [
    40             ['^BASE','dc=ma5,dc=lliurex,dc=net'],
    41             ['^URI','ldaps://'+servername]
     40            [u'^BASE',u'dc=ma5,dc=lliurex,dc=net'],
     41            [u'^URI',u'ldaps://'+servername]
    4242        ])
    4343        if ldap_conf_ok:
    44             output['etc_ldap_conf']={'syntax':'OK','content':content_ldap_conf}
    45         else:
    46             output['etc_ldap_conf'] = {'syntax': 'NOK', 'content': content_ldap_conf}
     44            output[u'etc_ldap_conf']={u'syntax':u'OK',u'content':content_ldap_conf}
     45        else:
     46            output[u'etc_ldap_conf'] = {u'syntax': u'NOK', u'content': content_ldap_conf}
    4747
    4848        if etc_ldap_ldap_conf_ok:
    49             output['etc_ldap_ldap_conf']={'syntax':'OK','content':content_etc_ldap_ldap_conf}
    50         else:
    51             output['etc_ldap_ldap_conf'] = {'syntax': 'NOK', 'content': content_etc_ldap_ldap_conf}
    52 
    53         nsswitch_content = self.uncomment('/etc/nsswitch.conf')
     49            output[u'etc_ldap_ldap_conf']={u'syntax':u'OK',u'content':content_etc_ldap_ldap_conf}
     50        else:
     51            output[u'etc_ldap_ldap_conf'] = {u'syntax': u'NOK', u'content': content_etc_ldap_ldap_conf}
     52
     53        nsswitch_content = self.uncomment(u'/etc/nsswitch.conf')
    5454        nsswitch_ok = self.file_find_line(nsswitch_content,
    5555        [
    56             ['passwd:','files','ldap'],
    57             ['group:','files','ldap'],
    58             ['shadow:','files','ldap']
     56            [u'passwd:',u'files',u'ldap'],
     57            [u'group:',u'files',u'ldap'],
     58            [u'shadow:',u'files',u'ldap']
    5959        ])
    6060        if nsswitch_ok:
    61             output['nsswitch_conf']={'syntax':'OK','content':nsswitch_content}
    62         else:
    63             output['nsswitch_conf'] = {'syntax': 'NOK', 'content': nsswitch_content}
     61            output[u'nsswitch_conf']={u'syntax':u'OK',u'content':nsswitch_content}
     62        else:
     63            output[u'nsswitch_conf'] = {u'syntax': u'NOK', u'content': nsswitch_content}
    6464        return output
    6565
    6666    def check_ports(self,*args,**kwargs):
    67         ports=['389','636']
     67        ports=[u'389',u'636']
    6868        server=args[0]
    6969        #localldap=args[1]
     
    7979            out[p]=self.check_open_port(server,p)
    8080        try:
    81             self.file_find_line(self.execute(run='netstat -nx'),'/var/run/slapd/ldapi')
    82             out['LDAPI']=True
     81            self.file_find_line(self.execute(run=u'netstat -nx'),u'/var/run/slapd/ldapi')
     82            out[u'LDAPI']=True
    8383        except Exception as e:
    84             out['LDAPI']=False
     84            out[u'LDAPI']=False
    8585        return out
    8686
     
    8989            return None
    9090        output = {}
    91         lines = args[0].split("\n")
     91        lines = args[0].split(u'\n')
    9292
    9393        path = output
    94         atrib=''
    95         value=''
     94        atrib=u''
     95        value=u''
    9696        for line in lines:
    97             if line=='':
     97            if line==u'':
    9898                path=output
    9999            else:
    100                 if line.startswith('dn: '):
    101                     hierarchy=line[4:].split(',')
     100                if line.startswith(u'dn: '):
     101                    hierarchy=line[4:].split(u',')
    102102                    hierarchy.reverse()
    103103                    for level in hierarchy:
     
    105105                            path[level]={}
    106106                        path = path[level]
    107                 elif line.startswith(' '):
     107                elif line.startswith(u' '):
    108108                    value=value+line[1:]
    109109                    path[atrib][-1]=value
    110110                else:
    111                     parts=line.split(' ')
     111                    parts=line.split(u' ')
    112112                    atrib=parts[0][:-1]
    113                     value=' '.join(parts[1:])
     113                    value=u' '.join(parts[1:])
    114114                    if atrib in path:
    115115                        path[atrib].append(value)
     
    128128        for k in d.keys():
    129129            if isinstance(d[k],dict):
    130                 split = k.split('=')
     130                split = k.split(u'=')
    131131                if len(split) > 1:
    132132                    aliaslevel = split[1]
     
    138138    def read_pass(self):
    139139        self.pwd=None
    140         sfile='/etc/ldap.secret'
     140        sfile=u'/etc/ldap.secret'
    141141        try:
    142142            if not os.path.exists(sfile):
    143143                sfile=None
    144144            else:
    145                 with open(sfile,'r') as f:
     145                with open(sfile,u'r') as f:
    146146                    self.pwd=f.read().strip()
    147147        except:
    148148            if sfile:
    149                 log.warning('Running as user, secret file verification is not possible')
     149                log.warning(u'Running as user, secret file verification is not possible')
    150150            pass
    151151
     
    155155            hash_digest_with_salt=base64.b64decode(base64.b64decode(p)[6:]).strip()
    156156            salt=hash_digest_with_salt[hashlib.sha1().digest_size:]
    157             compare=base64.b64encode("{SSHA}" + base64.encodestring(hashlib.sha1(str(self.pwd) + salt).digest() + salt))
     157            compare=base64.b64encode(u'{SSHA}' + base64.encodestring(hashlib.sha1(str(self.pwd) + salt).digest() + salt))
    158158            return p == compare
    159159        return None
    160160
    161161    def get_ldap_config(self,*args,**kwargs):
    162         release=str(args[0]).lower()
    163         server=str(args[1])
     162        release=unicode(args[0]).lower()
     163        server=unicode(args[1])
    164164        root_mode=self.check_root()
    165         kw={'stderr':None}
     165        kw={u'stderr':None}
    166166
    167167        if root_mode:
    168             kw.setdefault('asroot',True)
    169         auth="-Y EXTERNAL"
    170         uri="ldapi:///"
    171 
    172         if release=='client' and self.pwd:
    173             auth="-D cn=admin,dc=ma5,dc=lliurex,dc=net -w "+self.pwd
    174             uri="ldaps://"+server+":636"
    175 
    176         try:
    177             db=self.execute(run='ldapsearch {} -H {} -LLL'.format(auth,uri),**kw)
     168            kw.setdefault(u'asroot',True)
     169        auth=u'-Y EXTERNAL'
     170        uri=u'ldapi:///'
     171
     172        if release==u'client' and self.pwd:
     173            auth=u'-D cn=admin,dc=ma5,dc=lliurex,dc=net -w '+self.pwd
     174            uri=u'ldaps://'+server+u':636'
     175
     176        try:
     177            db=self.execute(run=u'ldapsearch {} -H {} -LLL'.format(auth,uri),**kw)
    178178            tree_db=self.parse_tree(db)
    179179        except:
     
    181181            tree_db=None
    182182        try:
    183             config=self.execute(run='ldapsearch {} -H {} -b cn=config -LLL'.format(auth,uri),**kw)
     183            config=self.execute(run=u'ldapsearch {} -H {} -b cn=config -LLL'.format(auth,uri),**kw)
    184184            tree_config=self.parse_tree(config)
    185185        except:
     
    188188
    189189        try:
    190             tree_db['net']['lliurex']['ma5']['o']
     190            tree_db[u'net'][u'lliurex'][u'ma5'][u'o']
    191191            init_done=True
    192192        except:
     
    195195        if tree_config:
    196196            good_pass=False
    197             if tree_config['config']['{1}mdb']['olcRootPW:'] and 'cn=admin,dc=ma5,dc=lliurex,dc=net' in tree_config['config']['{1}mdb']['olcRootDN']:
    198                 good_pass=self.checkpass(tree_config['config']['{1}mdb']['olcRootPW:'][0])
     197            if tree_config[u'config'][u'{1}mdb'][u'olcRootPW:'] and u'cn=admin,dc=ma5,dc=lliurex,dc=net' in tree_config[u'config'][u'{1}mdb'][u'olcRootDN']:
     198                good_pass=self.checkpass(tree_config[u'config'][u'{1}mdb'][u'olcRootPW:'][0])
    199199        else:
    200200            good_pass=None
    201         return {'CONFIG':tree_config,'DB':tree_db,'RAW_CONFIG':self.compress_file(string=config),'RAW_DB':self.compress_file(string=db),'INITIALIZED':init_done,'SECRET_STATUS':good_pass}
     201        return {u'CONFIG':tree_config,u'DB':tree_db,u'RAW_CONFIG':self.compress_file(string=config),u'RAW_DB':self.compress_file(string=db),u'INITIALIZED':init_done,u'SECRET_STATUS':good_pass}
    202202
    203203    def run(self,*args,**kwargs):
    204         out = {'LDAP_MASTER_IP':None}
     204        out = {u'LDAP_MASTER_IP':None}
    205205        output = {}
    206         release=kwargs['LLIUREX_RELEASE']
    207         vars=kwargs['N4D_VARS']
    208         mapping={'CLIENT_LDAP_URI':'SERVER_LDAP'}
     206        release=kwargs[u'LLIUREX_RELEASE']
     207        vars=kwargs[u'N4D_VARS']
     208        mapping={u'CLIENT_LDAP_URI':u'SERVER_LDAP'}
    209209        server=None
    210210        localldap=None
     
    212212        # Guess server ldap uri
    213213        for search_var in mapping:
    214             if search_var in vars and 'value' in vars[search_var]:
    215                 out.update({mapping[search_var]:vars[search_var]['value']})
    216                 server=vars[search_var]['value']
    217                 out.setdefault('LOCAL_LDAP',True)
     214            if search_var in vars and u'value' in vars[search_var]:
     215                out.update({mapping[search_var]:vars[search_var][u'value']})
     216                server=vars[search_var][u'value']
     217                out.setdefault(u'LOCAL_LDAP',True)
    218218                localldap=True
    219219        if not server:
    220             ip_server=self.check_ns('server')
     220            ip_server=self.check_ns(u'server')
    221221            try:
    222                 ip_server2=kwargs['NETINFO']['gw']['via']
     222                ip_server2=kwargs[u'NETINFO'][u'gw'][u'via']
    223223            except:
    224224                ip_server2=None
    225225
    226226            if not ip_server:
    227                 log.error("'server' not resolvable")
     227                log.error(u'\'server\' not resolvable')
    228228                if ip_server2:
    229229                    server=ip_server2
    230230                else:
    231                     log.error('not detected any gateway')
     231                    log.error(u'not detected any gateway')
    232232            else:
    233233                server=ip_server
    234234                if ip_server != ip_server2:
    235                     log.warning("'server' is not my gateway")
     235                    log.warning(u'\'server\' is not my gateway')
    236236            if server:
    237                 out.update({'SERVER_LDAP':server})
    238                 out.update({'LOCAL_LDAP':False})
     237                out.update({u'SERVER_LDAP':server})
     238                out.update({u'LOCAL_LDAP':False})
    239239                localldap=False
    240240            else:
    241                 out.update({'SERVER_LDAP':None})
    242                 out.update({'LOCAL_LDAP':None})
     241                out.update({u'SERVER_LDAP':None})
     242                out.update({u'LOCAL_LDAP':None})
    243243                localldap=None
    244244
    245245        self.read_pass()
    246246
    247         output['PORTS'] = self.check_ports(server,localldap)
     247        output[u'PORTS'] = self.check_ports(server,localldap)
    248248        mode=None
    249249
    250         if output['PORTS']['636']:
    251             output['CONFIG']=self.get_ldap_config(release,server)
    252             mode='UNKNOWN'
     250        if output[u'PORTS'][u'636']:
     251            output[u'CONFIG']=self.get_ldap_config(release,server)
     252            mode=u'UNKNOWN'
    253253            try:
    254                 test=output['CONFIG']['INITIALIZED']
     254                test=output[u'CONFIG'][u'INITIALIZED']
    255255            except:
    256                 mode='UNNINITIALIZED'
     256                mode=u'UNNINITIALIZED'
    257257            try:
    258                 test=output['CONFIG']['CONFIG']['config']['{1}mdb']['olcSyncrepl']
    259                 test=output['CONFIG']['CONFIG']['config']['{1}mdb']['olcUpdateRef']
    260                 mode='SLAVE'
    261                 if output['CONFIG']['CONFIG']['config']['{1}mdb']['olcSyncrepl'][0]:
    262                     m=re.search(r'provider=ldapi?://(?P<LDAP_MASTER_IP>\d+\.\d+\.\d+\.\d+)',output['CONFIG']['CONFIG']['config']['{1}mdb']['olcSyncrepl'][0])
     258                test=output[u'CONFIG'][u'CONFIG'][u'config'][u'{1}mdb'][u'olcSyncrepl']
     259                test=output[u'CONFIG'][u'CONFIG'][u'config'][u'{1}mdb'][u'olcUpdateRef']
     260                mode=u'SLAVE'
     261                if output[u'CONFIG'][u'CONFIG'][u'config'][u'{1}mdb'][u'olcSyncrepl'][0]:
     262                    m=re.search(r'provider=ldapi?://(?P<LDAP_MASTER_IP>\d+\.\d+\.\d+\.\d+)u',output['CONFIGu']['CONFIGu']['configu']['{1}mdbu']['olcSyncrepl'][0])
    263263                    if m:
    264264                        out.update(m.groupdict())
    265265            except:# indep or (master/slave(running without permissions))
    266                 mode='INDEPENDENT'
    267                 netinfo=kwargs['NETINFO']
     266                mode=u'INDEPENDENT'
     267                netinfo=kwargs[u'NETINFO']
    268268                if netinfo:
    269                     aliased_interfaces = [ k for k in netinfo if isinstance(netinfo[k],dict) and 'nalias' in netinfo[k] and netinfo[k]['nalias'] > 0 ]
     269                    aliased_interfaces = [ k for k in netinfo if isinstance(netinfo[k],dict) and u'nalias' in netinfo[k] and netinfo[k][u'nalias'] > 0 ]
    270270                    for i in aliased_interfaces:
    271                         for n in range(netinfo[i]['nalias']):
    272                             if 'alias'+str(n+1)+'_ifaddr' in netinfo[i]:
    273                                 ip_alias=netinfo[i]['alias'+str(n+1)+'_ifaddr'].split('.')[3].split('/')[0]
    274                                 if ip_alias=='1':
    275                                     mode='SLAVE'
    276                                 elif ip_alias=='254':
    277                                     mode='MASTER'
    278 
    279         output['FILES'] = self.check_files(release,mode,server)
    280         out.update( {'LDAP_INFO':output,'LDAP_MODE':mode})
     271                        for n in range(netinfo[i][u'nalias']):
     272                            if u'alias'+str(n+1)+u'_ifaddr' in netinfo[i]:
     273                                ip_alias=netinfo[i][u'alias'+str(n+1)+u'_ifaddr'].split(u'.')[3].split(u'/')[0]
     274                                if ip_alias==u'1':
     275                                    mode=u'SLAVE'
     276                                elif ip_alias==u'254':
     277                                    mode=u'MASTER'
     278
     279        output[u'FILES'] = self.check_files(release,mode,server)
     280        out.update( {u'LDAP_INFO':output,u'LDAP_MODE':mode})
    281281
    282282        return out
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxmounts.py

    r6441 r6450  
    55import os
    66
    7 log.debug("File "+__name__+" loaded")
     7log.debug(u'File '+__name__+u' loaded')
    88
    99class LlxMounts(Detector):
    1010
    11     _PROVIDES = ['MOUNTS_INFO','FSTAB','DISK_IDS','SERVER_SYNC_INFO']
    12     _NEEDS = ['HELPER_COMPRESS_FILE','HELPER_UNCOMMENT','HELPER_EXECUTE']
     11    _PROVIDES = [u'MOUNTS_INFO',u'FSTAB',u'DISK_IDS',u'SERVER_SYNC_INFO']
     12    _NEEDS = [u'HELPER_COMPRESS_FILE',u'HELPER_UNCOMMENT',u'HELPER_EXECUTE']
    1313
    1414    # def parse_findmnt(self,*args,**kwargs):
     
    1717    #     if type(ltree) == type(dict()):
    1818    #         d={}
    19     #         source=ltree['source']
     19    #         source=ltree[u'source']
    2020    #         m=re.search(r'(?P<source>/[\/\w:]+)(\[(?P<bind>\S+)\])?',source)
    2121    #         if m:
    2222    #             tmp=m.groupdict()
    23     #             if tmp['bind']:
    24     #                 d['mount_source'] = tmp['bind']
    25     #                 d['binding'] = tmp['source']
     23    #             if tmp[u'bind']:
     24    #                 d[u'mount_source'] = tmp[u'bind']
     25    #                 d[u'binding'] = tmp[u'source']
    2626    #             else:
    27     #                 d['mount_source'] = tmp['source']
    28     #         d['mount_path'] = ltree['target']
    29     #         d['fstype'] = ltree['fstype']
    30     #         d['options'] = ltree['options'].split(',')
     27    #                 d[u'mount_source'] = tmp[u'source']
     28    #         d[u'mount_path'] = ltree[u'target']
     29    #         d[u'fstype'] = ltree[u'fstype']
     30    #         d[u'options'] = ltree[u'options'].split(u',')
    3131    #         output.append(d)
    32     #         if 'children' in ltree:
    33     #             for ch in ltree['children']:
     32    #         if u'children' in ltree:
     33    #             for ch in ltree[u'children']:
    3434    #                 output.extend((self.parse_findmnt(ch)))
    3535    #     if type(ltree) == type(list()):
     
    4141    # def complete_binding_mapping(self,*args,**kwargs):
    4242    #     list = args[0]
    43     #     list_bindings = [ (x,list.index(x)) for x in list if 'binding' in x ]
     43    #     list_bindings = [ (x,list.index(x)) for x in list if u'binding' in x ]
    4444    #     list_sources = []
    4545    #     for b,idx in list_bindings:
    46     #         list_sources = [ (x,list.index(x)) for x in list if 'device' in x and x['device'] == b['binding']]
     46    #         list_sources = [ (x,list.index(x)) for x in list if u'device' in x and x[u'device'] == b[u'binding']]
    4747    #         k=0
    4848    #         for s,idx2 in list_sources:
    4949    #             k+=1
    50     #             list[idx]['binding_source_link'+str(k)]=s
     50    #             list[idx][u'binding_source_link'+str(k)]=s
    5151    #     return list
    5252
     
    5757        mounts = {}
    5858
    59         with open('/proc/self/mountinfo','r') as f:
     59        with open(u'/proc/self/mountinfo',u'r') as f:
    6060            for line in f:
    61                 values = line.rstrip().split(' ')
    62                 mid, pid, devid, root, mp, mopt = tuple(values[0:6])
    63                 tail = values [7:]
    64                 extra = []
    65                 for item in tail:
    66                     if item != '-':
    67                         extra.append(item)
    68                     else:
    69                         break
    70                 fstype, src, fsopt = tail[len(extra)+1:]
    71                 mount = {'mid':int(mid),'pid':int(pid),'devid':devid,'root':unescape(root),'mount_point':unescape(mp),'mount_options':mopt,'optional_fields':extra,'fstype':fstype,'mount_source':unescape(src),'superblock_options':fsopt}
    72                 mounts.setdefault(devid,[]).append(mount)
     61                try:
     62                    values = line.rstrip().split(u' ')
     63                    mid, pid, devid, root, mp, mopt = tuple(values[0:6])
     64                    tail = values [7:]
     65                    extra = []
     66                    for item in tail:
     67                        if item != u'-':
     68                            extra.append(item)
     69                        else:
     70                            break
     71                    fstype, src, fsopt = tail[len(extra)+1:]
     72                    mount = {u'mid':int(mid),u'pid':int(pid),u'devid':devid,u'root':unescape(root),u'mount_point':unescape(mp),u'mount_options':mopt,u'optional_fields':extra,u'fstype':fstype,u'mount_source':unescape(src),u'superblock_options':fsopt}
     73                    mounts.setdefault(devid,[]).append(mount)
     74                except Exception as e:
     75                    log.error(e)
    7376        all_mounts=[]
    7477        for devid,mnts in mounts.items():
     
    7881            if len(mnts) <= 1:
    7982                for mnt in mnts:
    80                     if mnt['mount_point'] not in [x['mount_point'] for x in all_mounts]:
     83                    if mnt[u'mount_point'] not in [x[u'mount_point'] for x in all_mounts]:
    8184                        # skip duplicated mount points
    82                         mnt.setdefault('is_binding', 'no')
     85                        mnt.setdefault(u'is_binding', u'no')
    8386                        all_mounts.append(mnt)
    8487                continue
    8588            # Sort list to get the first mount of the device's root dir (if still mounted)
    86             mnts.sort(key=lambda x: x['root'])
     89            mnts.sort(key=lambda x: x[u'root'])
    8790            src = mnts[0]
    88             src.setdefault('is_binding','no')
     91            src.setdefault(u'is_binding',u'no')
    8992            all_mounts.append(src)
    9093            binds = mnts[1:]
    9194            for bindmount in binds:
    92                 if src['root'] != bindmount['root']:
    93                     bindmount['mount_source'] = src['mount_point']+'/'+os.path.relpath(bindmount['root'],src['root'])
    94                 elif src['fstype'] == 'cifs':
    95                     bindmount['mount_source'] = src['mount_point']
    96                 elif src['fstype'] == 'nfs':
    97                     bindmount['mount_source'] = src['mount_point']+bindmount['mount_source'][len(src['mount_source']):]
    98 
    99 
    100                 bindmount.setdefault('is_binding','yes')
     95                if src[u'root'] != bindmount[u'root']:
     96                    bindmount[u'mount_source'] = src[u'mount_point']+u'/'+os.path.relpath(bindmount[u'root'],src[u'root'])
     97                elif src[u'fstype'] == u'cifs':
     98                    bindmount[u'mount_source'] = src[u'mount_point']
     99                elif src[u'fstype'] == u'nfs':
     100                    bindmount[u'mount_source'] = src[u'mount_point']+bindmount[u'mount_source'][len(src[u'mount_source']):]
     101
     102
     103                bindmount.setdefault(u'is_binding',u'yes')
    101104                all_mounts.append(bindmount)
    102         #        print '{0} -> {1[mount_point]} ({1[mount_options]})'.format(src['mount_point'],bindmount)
     105        #        print u'{0} -> {1[mount_point]} ({1[mount_options]})'.format(src[u'mount_point'],bindmount)
    103106        #for x in all_mounts:
    104         #    print '{mount_source} {mount_point} {fstype} {is_binding}'.format(**x)
     107        #    print u'{mount_source} {mount_point} {fstype} {is_binding}'.format(**x)
    105108        return all_mounts
    106109
    107110    def get_mounts(self,*args,**kwargs):
    108111        mounts=self.parse_self_mountinfo()
    109         #findmnt = json.loads(subprocess.check_output(['findmnt','-J'],stderr=open(os.devnull,'w')))
    110         #mounts = self.complete_binding_mapping(self.parse_findmnt(findmnt['filesystems']))
    111         output = {'PSEUDO':[],'DISK':[],'NETWORK':[],'BIND':[],'OTHER':[]}
     112        #findmnt = json.loads(subprocess.check_output([u'findmnt',u'-J'],stderr=open(os.devnull,u'w')))
     113        #mounts = self.complete_binding_mapping(self.parse_findmnt(findmnt[u'filesystems']))
     114        output = {u'PSEUDO':[],u'DISK':[],u'NETWORK':[],u'BIND':[],u'OTHER':[]}
    112115        #mounts =[]
    113         #with open('/proc/mounts', 'r') as f:
     116        #with open(u'/proc/mounts', u'r') as f:
    114117        #    reg = re.compile(r'^(?P<device>\S+)\s(?P<mount_path>\S+)\s(?P<type>\S+)\s(?P<options>\S+)\s(?P<dump>\S+)\s(?P<pass>\S+)$')
    115118        #    for line in f.readlines():
     
    117120        #        if m:
    118121        #            d=m.groupdict()
    119         #            d['options']=d['options'].split(',')
     122        #            d[u'options']=d[u'options'].split(u',')
    120123        #            mounts.append(d)
    121124
    122         mapping = {'PSEUDO': {'fstype':['sysfs','proc','devtmpfs','devpts','tmpfs','securityfs','cgroup','pstore','autofs','mqueue','debugfs','hugetlbfs','rpc_pipefs','fusectl','binfmt_misc','nfsd','gvfsd-fuse']},
    123                    'NETWORK':{'fstype':['nfs','cifs']},
    124                    'DISK':{'mount_source':['/dev/']},
    125                    'BIND':{'is_binding':['yes']} # 'B'ind is tested first, before 'D'isc
     125        mapping = {u'PSEUDO': {u'fstype':[u'sysfs',u'proc',u'devtmpfs',u'devpts',u'tmpfs',u'securityfs',u'cgroup',u'pstore',u'autofs',u'mqueue',u'debugfs',u'hugetlbfs',u'rpc_pipefs',u'fusectl',u'binfmt_misc',u'nfsd',u'gvfsd-fuse']},
     126                   u'NETWORK':{u'fstype':[u'nfs',u'cifs']},
     127                   u'DISK':{u'mount_source':[u'/dev/']},
     128                   u'BIND':{u'is_binding':[u'yes']} # u'B'ind is tested first, before u'D'isc
    126129                   }
    127130        for mount in mounts:
     
    140143                    break
    141144            if not done:
    142                 output['OTHER'].append(mount)
     145                output[u'OTHER'].append(mount)
    143146
    144147        return output
    145148
    146149    def get_server_sync(self,*args,**kwargs):
    147         if not os.path.isdir('/net/server-sync'):
    148             return 'NO_EXIST'
    149         lst=self.execute(run='getfacl -tp -R /net/server-sync/',stderr=None,asroot=True)
    150         regexp=re.compile('^#\sfile:\s/net/server-sync(\S+)')
     150        if not os.path.isdir(u'/net/server-sync'):
     151            return u'NO_EXIST'
     152        lst=self.execute(run=u'getfacl -tp -R /net/server-sync/',stderr=None,asroot=True)
     153        regexp=re.compile(u'^#\sfile:\s/net/server-sync(\S+)')
    151154        skip_search=False
    152155        d={}
     
    162165        attrs={}
    163166        if lst:
    164             for line in lst.split('\n'):
    165                 if line == '':
    166                     lsplit=[li for li in skip_search.split('/') if li != '']
    167                     if 'mask' in attrs:
    168                         attrs['acls']=True
     167            for line in lst.split(u'\n'):
     168                if line == u'':
     169                    lsplit=[li for li in skip_search.split(u'/') if li != u'']
     170                    if u'mask' in attrs:
     171                        attrs[u'acls']=True
    169172                    else:
    170                         attrs['acls']=False
     173                        attrs[u'acls']=False
    171174                    d.update(make_hierarchy(lsplit,attrs,d))
    172175                    skip_search=False
     
    174177                    continue
    175178                if skip_search:
    176                     fields=[ field for field in line.split(' ') if field != '']
    177                     attrs.setdefault('__'+fields[0],{})
     179                    fields=[ field for field in line.split(u' ') if field != u'']
     180                    attrs.setdefault(u'__'+fields[0],{})
    178181                    perms={}
    179                     if fields[0] not in ['mask','other']:
     182                    if fields[0] not in [u'mask',u'other']:
    180183                        skip_field=0
    181184                    else:
    182185                        skip_field=1
    183                     perms.setdefault('perms',fields[2-skip_field])
     186                    perms.setdefault(u'perms',fields[2-skip_field])
    184187                    try:
    185                         perms.setdefault('defaults',fields[3-skip_field])
     188                        perms.setdefault(u'defaults',fields[3-skip_field])
    186189                    except:
    187                         perms.setdefault('defaults',None)
    188 
    189                     attrs['__'+fields[0]].setdefault(fields[1],perms)
     190                        perms.setdefault(u'defaults',None)
     191
     192                    attrs[u'__'+fields[0]].setdefault(fields[1],perms)
    190193                    #attrs[fields[0]][fields[1]].append(perms)
    191194
     
    194197                    if m:
    195198                        skip_search=m[0]
    196                         if os.path.isdir('/net/server-sync'+skip_search):
    197                             attrs['__is_dir']=True
    198                             attrs['__is_file']=False
     199                        if os.path.isdir(u'/net/server-sync'+skip_search):
     200                            attrs[u'__is_dir']=True
     201                            attrs[u'__is_file']=False
    199202                        else:
    200                             attrs['__is_dir']=False
    201                             attrs['__is_file']=True
    202 
    203         d.setdefault('RAW',lst)
     203                            attrs[u'__is_dir']=False
     204                            attrs[u'__is_file']=True
     205
     206        d.setdefault(u'RAW',lst)
    204207        return d
    205208
    206209
    207210    def run(self,*args,**kwargs):
    208         output = {'MOUNTS_INFO':None}
    209         output['MOUNTS_INFO']=self.get_mounts()
    210         output['MOUNTS_INFO']['RAW']=self.compress_file(file='/proc/self/mounts')
    211         output['FSTAB']=self.uncomment('/etc/fstab')
    212         output['DISK_IDS']=self.execute(run='blkid',stderr=None)
    213         output['SERVER_SYNC_INFO']=self.get_server_sync()
     211        output = {u'MOUNTS_INFO':None}
     212        output[u'MOUNTS_INFO']=self.get_mounts()
     213        output[u'MOUNTS_INFO'][u'RAW']=self.compress_file(file=u'/proc/self/mounts')
     214        output[u'FSTAB']=self.uncomment(u'/etc/fstab')
     215        output[u'DISK_IDS']=self.execute(run=u'blkid',stderr=None)
     216        output[u'SERVER_SYNC_INFO']=self.get_server_sync()
    214217
    215218        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxn4d.py

    r6441 r6450  
    77import re
    88
    9 log.debug("File "+__name__+" loaded")
     9log.debug(u'File '+__name__+u' loaded')
    1010
    1111class LlxN4d(Detector):
    12     _NEEDS = ['HELPER_CHECK_OPEN_PORT','HELPER_CHECK_NS']
    13     _PROVIDES = ['N4D_VARS','N4D_STATUS','N4D_MODULES']
     12    _NEEDS = [u'HELPER_CHECK_OPEN_PORT',u'HELPER_CHECK_NS']
     13    _PROVIDES = [u'N4D_VARS',u'N4D_STATUS',u'N4D_MODULES']
    1414
    1515    def check_n4d(self,*args,**kwargs):
    1616        output ={}
    17         output['N4D_STATUS']={'online':str(self.check_open_port('9779'))}
    18         output['N4D_STATUS'].update({'resolvable':str(self.check_ns('server'))})
     17        output[u'N4D_STATUS']={u'online':unicode(self.check_open_port(u'9779'))}
     18        output[u'N4D_STATUS'].update({u'resolvable':unicode(self.check_ns(u'server'))})
    1919
    2020        try:
    21             if os.path.isfile('/var/log/n4d/n4d-server'):
    22                 with open('/var/log/n4d/n4d-server','r') as f:
     21            if os.path.isfile(u'/var/log/n4d/n4d-server'):
     22                with open(u'/var/log/n4d/n4d-server',u'r') as f:
    2323                    available=[]
    2424                    failed=[]
    2525                    lines=f.readlines()
    26                     ret=''
     26                    ret=u''
    2727                    for line in lines:
    28                         ret = ret + line.strip() + "\n"
     28                        ret = ret + line.strip() + u'\n'
    2929                        m = re.search(r'\s*\[(?P<pluginname>\w+)\]\s+\S+\s+\.+\s+(?P<status>\w+)?$',line.strip())
    3030                        if m:
    3131                            d=m.groupdict()
    32                             if d['status'] and d['pluginname']:
    33                                 if d['status'].lower() == 'ok':
    34                                     available.append(d['pluginname'])
     32                            if d[u'status'] and d[u'pluginname']:
     33                                if d[u'status'].lower() == u'ok':
     34                                    available.append(d[u'pluginname'])
    3535                                else:
    36                                     failed.append(d['pluginname'])
     36                                    failed.append(d[u'pluginname'])
    3737                    available=sorted(available)
    3838                    failed=sorted(failed)
    39                     output['N4D_MODULES']={'available':dict(zip(available,available)),'failed':dict(zip(failed,failed))}
     39                    output[u'N4D_MODULES']={u'available':dict(zip(available,available)),u'failed':dict(zip(failed,failed))}
    4040        except Exception as e:
    41             output['N4D_STATUS'].update({'initlog':'not available'})
    42             output['N4D_STATUS'].update({'initlog_error': str(e)})
     41            output[u'N4D_STATUS'].update({u'initlog':u'not available'})
     42            output[u'N4D_STATUS'].update({u'initlog_error': unicode(e)})
    4343
    4444        return output
     
    4646    def get_variables(self,*args,**kwargs):
    4747        vars={}
    48         folder='/var/lib/n4d/variables-dir/'
     48        folder=u'/var/lib/n4d/variables-dir/'
    4949        if os.path.exists(folder):
    5050            for f in os.listdir(folder):
    51                 file=folder+'/'+f
     51                file=folder+u'/'+f
    5252                try:
    53                     with open(file,'r') as f2:
     53                    with open(file,u'r') as f2:
    5454                        vars.update(json.load(f2))
    5555                except Exception as e:
    56                     vars[f]='NOT_READABLE {}'.format(e)
     56                    vars[f]=u'NOT_READABLE {}'.format(str(e).decode(u'utf-8'))
    5757        return vars
    5858
    5959    def run(self,*args,**kwargs):
    6060        output = {}
    61         output.update({'N4D_VARS':self.get_variables()})
     61        output.update({u'N4D_VARS':self.get_variables()})
    6262        output.update(self.check_n4d())
    6363        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxnethelpers.py

    r6399 r6450  
    88
    99
    10 log.debug("File "+__name__+" loaded")
     10log.debug(u'File '+__name__+u' loaded')
    1111
    1212class LlxNetHelpers(Detector):
    13     _PROVIDES = ['HELPER_CHECK_OPEN_PORT','HELPER_CHECK_NS','HELPER_CHECK_PING']
     13    _PROVIDES = [u'HELPER_CHECK_OPEN_PORT',u'HELPER_CHECK_NS',u'HELPER_CHECK_PING']
    1414    _NEEDS = []
    1515
     
    1919        if len(args) == 1:
    2020            port = str(args[0])
    21             host='127.0.0.1'
     21            host=u'127.0.0.1'
    2222            m=re.search(r'^\d+$',port)
    2323            if m:
     
    6262        ret=False
    6363        try:
    64             r=subprocess.check_call(['ping','-W1','-c1',str(args[0])],stderr=open(os.devnull,'w'),stdout=open(os.devnull,'w'))
     64            r=subprocess.check_call([u'ping',u'-W1',u'-c1',str(args[0])],stderr=open(os.devnull,u'w'),stdout=open(os.devnull,u'w'))
    6565            if r==0:
    6666                ret=True
     
    7070
    7171    def run(self,*args,**kwargs):
    72         return {'HELPER_CHECK_OPEN_PORT':{'code':self.check_open_port,'glob':globals()},
    73                 'HELPER_CHECK_NS':{'code':self.check_ns,'glob':globals()},
    74                 'HELPER_CHECK_PING':{'code':self.check_ping,'glob':globals()}
     72        return {u'HELPER_CHECK_OPEN_PORT':{u'code':self.check_open_port,u'glob':globals()},
     73                u'HELPER_CHECK_NS':{u'code':self.check_ns,u'glob':globals()},
     74                u'HELPER_CHECK_PING':{u'code':self.check_ping,u'glob':globals()}
    7575                }
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxnetwork.py

    r6441 r6450  
    66from os import environ
    77
    8 log.debug("File "+__name__+" loaded")
     8log.debug(u'File '+__name__+u' loaded')
    99
    1010class LlxNetwork(Detector):
    1111
    12     _PROVIDES=["NETINFO"]
    13     _NEEDS=['HELPER_UNCOMMENT',"HELPER_GET_FILE_FROM_NET","HELPER_EXECUTE",'HELPER_COMPACT_FILES']
     12    _PROVIDES=[u'NETINFO']
     13    _NEEDS=[u'HELPER_UNCOMMENT',u'HELPER_GET_FILE_FROM_NET',u'HELPER_EXECUTE',u'HELPER_COMPACT_FILES']
    1414
    1515    def get_routes(self,*args,**kwargs):
    16         routes = self.execute(run="ip r",stderr=None)
     16        routes = self.execute(run=u'ip r',stderr=None)
    1717        if not routes:
    1818            return None
    1919        else:
    20             routes=routes.split("\n")
     20            routes=routes.split(u'\n')
    2121            rt = {}
    22             rt['names'] = {}
    23             rt['names']['bynet'] = {}
    24             rt['names']['byiface'] = {}
     22            rt[u'names'] = {}
     23            rt[u'names'][u'bynet'] = {}
     24            rt[u'names'][u'byiface'] = {}
    2525            for line in routes:
    26                 if 'default' in line:
     26                if u'default' in line:
    2727                    m = re.search(r'default via (?P<via>\S+) dev (?P<dev>\w+)', line)
    2828                    d = m.groupdict()
    29                     if not d['dev'] in rt:
    30                         rt[d['dev']] = []
    31                     rt[d['dev']].append({'src': '0.0.0.0', 'net': d['via']})
    32                     rt['names']['default'] = {'via': d['via'], 'dev': d['dev']}
    33                     rt['names']['gw'] = d['via']
     29                    if not d[u'dev'] in rt:
     30                        rt[d[u'dev']] = []
     31                    rt[d[u'dev']].append({u'src': u'0.0.0.0', u'net': d[u'via']})
     32                    rt[u'names'][u'default'] = {u'via': d[u'via'], u'dev': d[u'dev']}
     33                    rt[u'names'][u'gw'] = d[u'via']
    3434                else:
    3535                    m = re.search(
     
    3737                        line)
    3838                    d = m.groupdict()
    39                     if not 'src' in d or d['src'] == None:
    40                         d['src'] = 'unknown'
    41                     if not d['dev'] in rt:
    42                         rt[d['dev']] = []
    43                     rt[d['dev']].append({'src': d['src'], 'net': d['net']})
    44                     rt['names']['byiface'][d['src']] = d['net']
    45                     rt['names']['bynet'][d['net']] = d['src']
    46 
    47             rt.setdefault('RAW',routes)
     39                    if not u'src' in d or d[u'src'] == None:
     40                        d[u'src'] = u'unknown'
     41                    if not d[u'dev'] in rt:
     42                        rt[d[u'dev']] = []
     43                    rt[d[u'dev']].append({u'src': d[u'src'], u'net': d[u'net']})
     44                    rt[u'names'][u'byiface'][d[u'src']] = d[u'net']
     45                    rt[u'names'][u'bynet'][d[u'net']] = d[u'src']
     46
     47            rt.setdefault(u'RAW',routes)
    4848            return rt
    4949
    5050    def get_resolver(self,*args,**kwargs):
    51         resolv_lines=self.uncomment('/etc/resolv.conf')
     51        resolv_lines=self.uncomment(u'/etc/resolv.conf')
    5252        output={}
    53         for line in resolv_lines.split("\n"):
     53        for line in resolv_lines.split(u'\n'):
    5454            m=re.search(r'(?:nameserver\s+(?P<nameserver>\S+)|search\s+(?P<search>\w+)|domain\s+(?P<domain>\w+))',line)
    5555            if m:
    5656                d=m.groupdict()
    57                 for key in ['nameserver','search','domain']:
     57                for key in [u'nameserver',u'search',u'domain']:
    5858                    if key in d and d[key] != None:
    5959                        output[key]=d[key]
    60         output.setdefault('RAW',resolv_lines)
     60        output.setdefault(u'RAW',resolv_lines)
    6161        return output
    6262
    6363
    6464    def get_ifaces(self,*args,**kwargs):
    65         devs = listdir("/sys/class/net/")
     65        devs = listdir(u'/sys/class/net/')
    6666        output = {}
    6767        regif = []
     
    7575        for dev in devs:
    7676            aliasnum = 1
    77             info = self.execute(run="ip addr show "+dev,stderr=None).replace("\n", "")
     77            info = self.execute(run=u'ip addr show '+dev,stderr=None).replace(u'\n', u'')
    7878            for i in range(0, len(regif)):
    7979                m = [x for x in re.finditer(regif[i], info)]
    8080                for x in m:
    8181                    d = x.groupdict()
    82                     if 'iface' in d:
    83                         iface = d['iface']
     82                    if u'iface' in d:
     83                        iface = d[u'iface']
    8484                        output[iface] = {}
    8585                    else:
    86                         if 'type' in d:
    87                             if ':' in d['type']:
     86                        if u'type' in d:
     87                            if u':' in d[u'type']:
    8888                                for x in d:
    89                                     output[iface].update({'alias' + str(aliasnum) + '_' + x: d[x]})
     89                                    output[iface].update({u'alias' + str(aliasnum) + u'_' + x: d[x]})
    9090                                aliasnum = aliasnum + 1
    9191                            else:
    92                                 #d.update({'nalias':0})
     92                                #d.update({u'nalias':0})
    9393                                output[iface].update(d)
    9494                        else:
    9595                            output[iface].update(d)
    9696            if aliasnum > 1:
    97                 output[iface].update({'nalias': aliasnum - 1})
     97                output[iface].update({u'nalias': aliasnum - 1})
    9898                aliasnum = 1
    99         output.setdefault('RAW',self.execute(run='ifconfig -a',stderr=None))
     99        output.setdefault(u'RAW',self.execute(run=u'ifconfig -a',stderr=None))
    100100        return output
    101101
     
    104104        done=False
    105105        for x in environ:
    106             if 'proxy' in x.lower():
     106            if u'proxy' in x.lower():
    107107                output[x]=environ[x]
    108108        try:
    109             output.setdefault('RAW_ENVIRON',output.copy())
     109            output.setdefault(u'RAW_ENVIRON',output.copy())
    110110        except:
    111111            pass
    112112
    113113        try:
    114             o = self.execute(run="dconf dump /system/proxy/",stderr=None)
     114            o = self.execute(run=u'dconf dump /system/proxy/',stderr=None)
    115115            save_next=False
    116116            prev= None
    117117            skip_line=False
    118             for line in o.split("\n"):
     118            for line in o.split(u'\n'):
    119119                line=line.strip()
    120                 if line == "":
     120                if line == u'':
    121121                    continue
    122122                if skip_line:
    123123                    skip_line=False
    124                 keys=['[/]', '[http]', '[https]']
    125                 store_keys=['autoconfig','http','https']
     124                keys=[u'[/]', u'[http]', u'[https]']
     125                store_keys=[u'autoconfig',u'http',u'https']
    126126                for keynum in range(len(keys)):
    127127                    if keys[keynum] in line:
     
    133133                    continue
    134134                if save_next:
    135                     m = re.search(r"(?:autoconfig-url=\'(?P<autoconfig>\S+)\'|mode=\'(?P<mode>\w+)\'|host=\'(?P<host>\S+)\'|port=(?P<port>\d+))",line)
     135                    m = re.search(r"(?:autoconfig-url=\u'(?P<autoconfig>\S+)\'|mode=\u'(?P<mode>\w+)\'|host=\u'(?P<host>\S+)\'|port=(?P<port>\d+))",line)
    136136                    if m:
    137137                        d=m.groupdict()
     
    147147            raise(e)
    148148
    149         if 'autoconfig' in output:
    150             pacfile=self.get_file_from_net(output['autoconfig']['autoconfig'])
     149        if u'autoconfig' in output:
     150            pacfile=self.get_file_from_net(output[u'autoconfig'][u'autoconfig'])
    151151            if pacfile:
    152                 output['autoconfig']['pacfile'] = pacfile
     152                output[u'autoconfig'][u'pacfile'] = pacfile
    153153            else:
    154                 output['autoconfig']['pacfile'] = ''
     154                output[u'autoconfig'][u'pacfile'] = u''
    155155
    156156        try:
    157             output.setdefault('RAW_DCONF',o)
     157            output.setdefault(u'RAW_DCONF',o)
    158158        except:
    159159            pass
     
    161161
    162162    def get_listens(self,*args,**kwargs):
    163         netstat_listen=self.execute(run='netstat -4tuln',stderr=None).split("\n")
     163        netstat_listen=self.execute(run=u'netstat -4tuln',stderr=None).split(u'\n')
    164164        # TODO:CHECK PROCESS USING PORT AND STORE IT
    165165        regexp=re.compile(r'(?P<PROTO>\w+)\s+\d+\s+\d+\s+(?P<LISTEN_ON>[^:\s]+):(?P<PORT>\d+)\s+.*$')
    166         netstat_info={'BYPROTO':{},'BYPORT':{}}
     166        netstat_info={u'BYPROTO':{},u'BYPORT':{}}
    167167        for line in netstat_listen:
    168168            listen_info = re.search(regexp,line)
    169169            if listen_info:
    170170                d=listen_info.groupdict()
    171                 proto=d['PROTO']
    172                 port=d['PORT']
    173                 if proto not in netstat_info['BYPROTO']:
    174                     netstat_info['BYPROTO'][proto]={}
    175                 if port in netstat_info['BYPROTO'][proto]:
    176                     netstat_info['BYPROTO'][proto][port].append(d['LISTEN_ON'])
     171                proto=d[u'PROTO']
     172                port=d[u'PORT']
     173                if proto not in netstat_info[u'BYPROTO']:
     174                    netstat_info[u'BYPROTO'][proto]={}
     175                if port in netstat_info[u'BYPROTO'][proto]:
     176                    netstat_info[u'BYPROTO'][proto][port].append(d[u'LISTEN_ON'])
    177177                else:
    178                     netstat_info['BYPROTO'][proto][port]=[d['LISTEN_ON']]
    179 
    180                 if port not in netstat_info['BYPORT']:
    181                     netstat_info['BYPORT'][port]={}
    182                 if proto in netstat_info['BYPORT'][port]:
    183                     netstat_info['BYPORT'][port][proto].append(d['LISTEN_ON'])
     178                    netstat_info[u'BYPROTO'][proto][port]=[d[u'LISTEN_ON']]
     179
     180                if port not in netstat_info[u'BYPORT']:
     181                    netstat_info[u'BYPORT'][port]={}
     182                if proto in netstat_info[u'BYPORT'][port]:
     183                    netstat_info[u'BYPORT'][port][proto].append(d[u'LISTEN_ON'])
    184184                else:
    185                     netstat_info['BYPORT'][port][proto]=[d['LISTEN_ON']]
    186         netstat_info.setdefault('RAW',netstat_listen)
     185                    netstat_info[u'BYPORT'][port][proto]=[d[u'LISTEN_ON']]
     186        netstat_info.setdefault(u'RAW',netstat_listen)
    187187        return netstat_info
    188188
     
    192192
    193193        for dev in output:
    194             if 'ifaddr' in output[dev] and output[dev]['ifaddr']:
    195                 ip=output[dev]['ifaddr'].split('/')[0]
     194            if u'ifaddr' in output[dev] and output[dev][u'ifaddr']:
     195                ip=output[dev][u'ifaddr'].split(u'/')[0]
    196196                try:
    197                     output[dev]['net']=rt['names']['byiface'][ip]
     197                    output[dev][u'net']=rt[u'names'][u'byiface'][ip]
    198198                except:
    199199                    pass
    200         output['routes']=rt
     200        output[u'routes']=rt
    201201        if rt:
    202             output['gw']=rt['names']['default']
     202            output[u'gw']=rt[u'names'][u'default']
    203203        else:
    204             output['gw']=None
     204            output[u'gw']=None
    205205
    206206        resolv=self.get_resolver()
    207         output['resolver']=resolv
     207        output[u'resolver']=resolv
    208208
    209209        proxy=self.get_proxy()
    210         output['proxy']=proxy
    211 
    212         output['netstat']=self.get_listens()
    213         output['network_interfaces']=self.compact_files(path=['/etc/network/interfaces','/etc/network/interfaces.d/'])
    214         output['iptables_rules']=self.execute(run='iptables -L',stderr=None,asroot=True)
    215         forward=self.execute(run='sysctl -n net.ipv4.ip_forward',stderr=None)
    216         if forward == '1':
    217             output['forwading']=True
     210        output[u'proxy']=proxy
     211
     212        output[u'netstat']=self.get_listens()
     213        output[u'network_interfaces']=self.compact_files(path=[u'/etc/network/interfaces',u'/etc/network/interfaces.d/'])
     214        output[u'iptables_rules']=self.execute(run=u'iptables -L',stderr=None,asroot=True)
     215        forward=self.execute(run=u'sysctl -n net.ipv4.ip_forward',stderr=None)
     216        if forward == u'1':
     217            output[u'forwading']=True
    218218        else:
    219             output['forwading']=False
     219            output[u'forwading']=False
    220220        #s=json.dumps(output)
    221221
    222         return {'NETINFO':output}
     222        return {u'NETINFO':output}
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxnetworkresolver.py

    r6399 r6450  
    44import re
    55
    6 log.debug("File "+__name__+" loaded")
     6log.debug(u'File '+__name__+u' loaded')
    77
    88class LlxNetworkResolver(Detector):
    99
    10     _PROVIDES=["RESOLVER_INFO"]
    11     _NEEDS=["LLIUREX_RELEASE","LLIUREX_SESSION_TYPE",'HELPER_CHECK_OPEN_PORT','HELPER_CHECK_ROOT','HELPER_CHECK_NS','LDAP_MODE','HELPER_CHECK_PING','LDAP_MASTER_IP','N4D_VARS']
     10    _PROVIDES=[u'RESOLVER_INFO']
     11    _NEEDS=[u'LLIUREX_RELEASE',u'LLIUREX_SESSION_TYPE',u'HELPER_CHECK_OPEN_PORT',u'HELPER_CHECK_ROOT',u'HELPER_CHECK_NS',u'LDAP_MODE',u'HELPER_CHECK_PING',u'LDAP_MASTER_IP',u'N4D_VARS']
    1212
    1313    def __init__(self,*args,**kwargs):
    14         self.output={'RESOLVED': [] ,'UNRESOLVED':[],'REACHABLE':[],'UNREACHABLE':[],'STATUS':True}
     14        self.output={u'RESOLVED': [] ,u'UNRESOLVED':[],u'REACHABLE':[],u'UNREACHABLE':[],u'STATUS':True}
    1515
    1616    def addr_checks(self,*args,**kwargs):
    17         ns=str(args[0])
     17        ns=unicode(args[0])
    1818        ret=False
    19         only_ip = re.findall('\d+\.\d+\.\d+\.\d+',ns)
     19        only_ip = re.findall(u'\d+\.\d+\.\d+\.\d+',ns)
    2020        go_to_ping = True
    2121
     
    2525            ip=self.check_ns(ns)
    2626            if ip:
    27                 self.output['RESOLVED'].append(ns)
     27                self.output[u'RESOLVED'].append(ns)
    2828
    2929            else:
    30                 self.output['UNRESOLVED'].append(ns)
     30                self.output[u'UNRESOLVED'].append(ns)
    3131                go_to_ping=False
    3232
    3333        if go_to_ping:
    3434            if only_ip:
    35                 ns=''
     35                ns=u''
    3636            else:
    37                 ns='({})'.format(ns)
     37                ns=u'({})'.format(ns)
    3838            if self.check_ping(ip):
    39                 self.output['REACHABLE'].append('{} {}'.format(ip,ns))
     39                self.output[u'REACHABLE'].append(u'{} {}'.format(ip,ns))
    4040                ret=True
    4141            else:
    42                 self.output['UNREACHABLE'].append('{} {}'.format(ip,ns))
     42                self.output[u'UNREACHABLE'].append(u'{} {}'.format(ip,ns))
    4343
    4444        return ret
    4545
    4646    def run(self,*args,**kwargs):
    47         release=kwargs['LLIUREX_RELEASE']
     47        release=kwargs[u'LLIUREX_RELEASE']
    4848        if release:
    4949            release=release.lower()
    50         session=kwargs["LLIUREX_SESSION_TYPE"]
     50        session=kwargs[u'LLIUREX_SESSION_TYPE']
    5151        if session:
    5252            session = session.lower()
    53         ldap_mode=kwargs["LDAP_MODE"]
     53        ldap_mode=kwargs[u'LDAP_MODE']
    5454        if ldap_mode:
    5555            ldap_mode=ldap_mode.lower()
    56         ldap_master_ip=kwargs['LDAP_MASTER_IP']
    57         n4d_vars=kwargs['N4D_VARS']
     56        ldap_master_ip=kwargs[u'LDAP_MASTER_IP']
     57        n4d_vars=kwargs[u'N4D_VARS']
    5858
    59         nslist=['server']
     59        nslist=[u'server']
    6060
    61         if release == 'server': # SERVERS
    62             if ldap_mode == 'slave':
     61        if release == u'server': # SERVERS
     62            if ldap_mode == u'slave':
    6363                if ldap_master_ip:
    6464                    nslist.append(ldap_master_ip)
     
    6767                    #     # if i'm root and is not set ldap_master_ip, there is an error
    6868                    #     # If i'm not root, ldap_master_ip is impossible to get from ldap
    69                     #     self.output['STATUS']=False
     69                    #     self.output[u'STATUS']=False
    7070
    71                     if n4d_vars['MASTER_SERVER_IP'] and n4d_vars['MASTER_SERVER_IP']['value']:
    72                         nslist.append(n4d_vars['MASTER_SERVER_IP']['value'])
     71                    if n4d_vars[u'MASTER_SERVER_IP'] and n4d_vars[u'MASTER_SERVER_IP'][u'value']:
     72                        nslist.append(n4d_vars[u'MASTER_SERVER_IP'][u'value'])
    7373                    # else:
    74                     #     self.output['STATUS']=False
     74                    #     self.output[u'STATUS']=False
    7575
    76             elif ldap_mode == 'independent':
     76            elif ldap_mode == u'independent':
    7777                pass
    78             elif ldap_mode == 'master':
     78            elif ldap_mode == u'master':
    7979                pass
    8080            else:
    8181                pass
    82         elif release == 'client': # CLIENTS
     82        elif release == u'client': # CLIENTS
    8383            pass
    8484        else: # OTHERS
    8585            pass
    8686
    87         nslist.extend(['pmb','opac','proxy','owncloud','jclic-aula','cups','share','mirror','preseed','www','ntp','srv','servidor','lliurexlab','error','ipxeboot','admin-center','lliurex-mirror'])
     87        nslist.extend([u'pmb',u'opac',u'proxy',u'owncloud',u'jclic-aula',u'cups',u'share',u'mirror',u'preseed',u'www',u'ntp',u'srv',u'servidor',u'lliurexlab',u'error',u'ipxeboot',u'admin-center',u'lliurex-mirror'])
    8888        for ns in nslist:
    8989            r = self.addr_checks(ns)
    9090            # if not r:
    91             #     self.output['STATUS']=False
     91            #     self.output[u'STATUS']=False
    9292
    93         return {'RESOLVER_INFO': self.output}
     93        return {u'RESOLVER_INFO': self.output}
    9494
    9595
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxnetworktest.py

    r6399 r6450  
    33import hwdetector.utils.log as log
    44
    5 log.debug("File "+__name__+" loaded")
     5log.debug(u'File '+__name__+u' loaded')
    66
    77class LlxNetworkTest(Detector):
    8     _NEEDS=['NETINFO','RESOLVER_INFO','HELPER_CHECK_PING','LLIUREX_RELEASE','HELPER_GET_FILE_FROM_NET']
    9     #_PROVIDES=['LLXNETWORK_TEST']
    10     _PROVIDES=['NETINFO']
     8    _NEEDS=[u'NETINFO',u'RESOLVER_INFO',u'HELPER_CHECK_PING',u'LLIUREX_RELEASE',u'HELPER_GET_FILE_FROM_NET']
     9    #_PROVIDES=[u'LLXNETWORK_TEST']
     10    _PROVIDES=[u'NETINFO']
    1111
    1212    # def make_result(self,*args,**kwargs):
    13     #     ret=''
    14     #     if not ('result' in kwargs and 'msg' in kwargs):
     13    #     ret=u''
     14    #     if not (u'result' in kwargs and u'msg' in kwargs):
    1515    #         return
    16     #     if type(kwargs['result']) == type(list()):
    17     #         result=kwargs['result']
     16    #     if type(kwargs[u'result']) == type(list()):
     17    #         result=kwargs[u'result']
    1818    #     else:
    19     #         result=[str(kwargs['result'])]
     19    #         result=[str(kwargs[u'result'])]
    2020    #
    2121    #     for x in result:
    22     #         ret+='{}> {}: {}\n'.format(self.__class__.__name__,x,kwargs['msg'])
     22    #         ret+=u'{}> {}: {}\n'.format(self.__class__.__name__,x,kwargs[u'msg'])
    2323    #     return ret
    2424
     
    2828        status=True
    2929
    30         netinfo=kwargs['NETINFO']
    31         resolution=kwargs['RESOLVER_INFO']
    32         release=str(kwargs['LLIUREX_RELEASE']).lower()
     30        netinfo=kwargs[u'NETINFO']
     31        resolution=kwargs[u'RESOLVER_INFO']
     32        release=str(kwargs[u'LLIUREX_RELEASE']).lower()
    3333
    3434        # CHECK NETWORK STATUS
    3535
    36         # ifaces = [x for x in netinfo.keys() if x.startswith('eth')]
     36        # ifaces = [x for x in netinfo.keys() if x.startswith(u'eth')]
    3737        # for x in ifaces:
    38         #     if netinfo[x]['state'].lower() == 'up':
    39         #         msg.append(self.make_result(result=x,msg='Ok! it\'s up (link-detected)'))
     38        #     if netinfo[x][u'state'].lower() == u'up':
     39        #         msg.append(self.make_result(result=x,msg=u'Ok! it\'s up (link-detected)'))
    4040        #     else:
    41         #         msg.append(self.make_result(result=x,msg='Nok ! it\'s down (no-link)'))
     41        #         msg.append(self.make_result(result=x,msg=u'Nok ! it\'s down (no-link)'))
    4242        #         status=False
    4343
    4444        # try:
    45         #     gw=netinfo['gw']['via']
     45        #     gw=netinfo[u'gw'][u'via']
    4646        #     if self.check_ping(gw):
    47         #         msg.append(self.make_result(result=gw,msg='Ok! gateway it\'s reachable'))
     47        #         msg.append(self.make_result(result=gw,msg=u'Ok! gateway it\'s reachable'))
    4848        #     else:
    4949        #         status=False
     
    5151        # except:
    5252        #     status=False
    53         #     msg.append(self.make_result(result=x,msg='Nok! gateway not reachable'))
     53        #     msg.append(self.make_result(result=x,msg=u'Nok! gateway not reachable'))
    5454
    5555        try:
    56             gw=netinfo['gw']['via']
     56            gw=netinfo[u'gw'][u'via']
    5757            if self.check_ping(gw):
    58                 netinfo['gw']['reachable']=True
     58                netinfo[u'gw'][u'reachable']=True
    5959            else:
    60                 netinfo['gw']['reachable']=False
     60                netinfo[u'gw'][u'reachable']=False
    6161        except:
    6262            pass
    6363
    64         netinfo['internet']={}
     64        netinfo[u'internet']={}
    6565        try:
    66             netinfo['internet'].setdefault('ping',self.check_ping('8.8.8.8'))
    67             netinfo['internet'].setdefault('http_get',False)
    68             if self.get_file_from_net('http://lliurex.net',False):
    69                 netinfo['internet']['http_get']=True
     66            netinfo[u'internet'].setdefault(u'ping',self.check_ping(u'8.8.8.8'))
     67            netinfo[u'internet'].setdefault(u'http_get',False)
     68            if self.get_file_from_net(u'http://lliurex.net',False):
     69                netinfo[u'internet'][u'http_get']=True
    7070        except:
    7171            pass
    7272
    73         if not netinfo['internet'].get('http_get'):
     73        if not netinfo[u'internet'].get(u'http_get'):
    7474            try:
    7575                proxydata={}
    76                 if netinfo['proxy']['autoconfig'] and netinfo['proxy']['autoconfig'].get('mode',None) == 'auto':
    77                     proxydata.setdefault('proxy',True)
     76                if netinfo[u'proxy'][u'autoconfig'] and netinfo[u'proxy'][u'autoconfig'].get(u'mode',None) == u'auto':
     77                    proxydata.setdefault(u'proxy',True)
    7878                else:
    79                     if 'http' in netinfo['proxy'] and netinfo['proxy']['http']:
    80                         proxydata.setdefault('proxy_http',netinfo['proxy']['http'])
    81                         proxydata.setdefault('proxy',True)
    82                     if 'https' in netinfo['proxy'] and netinfo['proxy']['https']:
    83                         proxydata.setdefault('proxy_https',netinfo['proxy']['https'])
    84                         proxydata.setdefault('proxy',True)
    85                     if 'proxy_http' in netinfo['proxy']:
    86                         proxydata.setdefault('proxy_http',netinfo['proxy']['http_proxy'])
    87                         proxydata.setdefault('proxy',True)
    88                     if 'proxy_https' in netinfo['proxy']:
    89                         proxydata.setdefault('proxy_https',netinfo['proxy']['https_proxy'])
    90                         proxydata.setdefault('proxy',True)
     79                    if u'http' in netinfo[u'proxy'] and netinfo[u'proxy'][u'http']:
     80                        proxydata.setdefault(u'proxy_http',netinfo[u'proxy'][u'http'])
     81                        proxydata.setdefault(u'proxy',True)
     82                    if u'https' in netinfo[u'proxy'] and netinfo[u'proxy'][u'https']:
     83                        proxydata.setdefault(u'proxy_https',netinfo[u'proxy'][u'https'])
     84                        proxydata.setdefault(u'proxy',True)
     85                    if u'proxy_http' in netinfo[u'proxy']:
     86                        proxydata.setdefault(u'proxy_http',netinfo[u'proxy'][u'http_proxy'])
     87                        proxydata.setdefault(u'proxy',True)
     88                    if u'proxy_https' in netinfo[u'proxy']:
     89                        proxydata.setdefault(u'proxy_https',netinfo[u'proxy'][u'https_proxy'])
     90                        proxydata.setdefault(u'proxy',True)
    9191
    92                 netinfo['internet']['http_get']= False
    93                 if self.get_file_from_net('http://lliurex.net',**proxydata):
    94                     netinfo['internet']['http_get']= True
     92                netinfo[u'internet'][u'http_get']= False
     93                if self.get_file_from_net(u'http://lliurex.net',**proxydata):
     94                    netinfo[u'internet'][u'http_get']= True
    9595            except:
    9696                pass
    9797
    9898
    99             #netinfo['name_resolution']=
     99            #netinfo[u'name_resolution']=
    100100        # def check_internet(msg,proxy=False):
    101101        #     try:
    102         #         if proxy or self.check_ping('8.8.8.8'):
     102        #         if proxy or self.check_ping(u'8.8.8.8'):
    103103        #             if not proxy:
    104         #                 msg.append(self.make_result(result='Internet ICMP',msg='Ok! conectivity available'))
    105         #             if self.get_file_from_net('http://lliurex.net',proxy):
    106         #                 msg.append(self.make_result(result='Lliurex.net',msg='Ok! conectivity available'))
     104        #                 msg.append(self.make_result(result=u'Internet ICMP',msg=u'Ok! conectivity available'))
     105        #             if self.get_file_from_net(u'http://lliurex.net',proxy):
     106        #                 msg.append(self.make_result(result=u'Lliurex.net',msg=u'Ok! conectivity available'))
    107107        #             else:
    108         #                 msg.append(self.make_result(result='Lliurex.net',msg='Nok! conectivity not available'))
     108        #                 msg.append(self.make_result(result=u'Lliurex.net',msg=u'Nok! conectivity not available'))
    109109        #         else:
    110110        #             raise Exception()
    111111        #     except Exception as e:
    112         #         msg.append(self.make_result(result='Internet ICMP',msg='Nok! connectivity not available'))
     112        #         msg.append(self.make_result(result=u'Internet ICMP',msg=u'Nok! connectivity not available'))
    113113        #     return msg
    114114
    115         # if release != 'client':
     115        # if release != u'client':
    116116        #     check_internet(msg)
    117117        # else:
    118118        #     try:
    119         #         mode= netinfo['proxy']['autoconfig']['mode']
    120         #         if mode == 'auto':
    121         #             pac=netinfo['proxy']['autoconfig']
    122         #             if netinfo['proxy']['autoconfig']['pacfile'] != 'NOT_AVAILABLE':
    123         #                 msg.append(self.make_result(result='Proxy autoconfig',msg='Ok! Pac file available'))
     119        #         mode= netinfo[u'proxy'][u'autoconfig'][u'mode']
     120        #         if mode == u'auto':
     121        #             pac=netinfo[u'proxy'][u'autoconfig']
     122        #             if netinfo[u'proxy'][u'autoconfig'][u'pacfile'] != u'NOT_AVAILABLE':
     123        #                 msg.append(self.make_result(result=u'Proxy autoconfig',msg=u'Ok! Pac file available'))
    124124        #                 check_internet(msg,True)
    125125        #             else:
    126         #                 msg.append(self.make_result(result='Proxy autoconfig',msg='Nok! file not available'))
    127         #         elif mode != 'none':
     126        #                 msg.append(self.make_result(result=u'Proxy autoconfig',msg=u'Nok! file not available'))
     127        #         elif mode != u'none':
    128128        #             check_internet(msg,True)
    129129        #     except Exception as e:
    130         #         msg.append(self.make_result(result='Proxy',msg='not using proxy'))
     130        #         msg.append(self.make_result(result=u'Proxy',msg=u'not using proxy'))
    131131        #         check_internet(msg)
    132132
    133133        # CHECK NAME RESOLUTION
    134134
    135         # if resolution['UNRESOLVED']:
    136         #     msg.append(self.make_result(result=resolution['UNRESOLVED'],msg='Nok ! not resolvable'))
     135        # if resolution[u'UNRESOLVED']:
     136        #     msg.append(self.make_result(result=resolution[u'UNRESOLVED'],msg=u'Nok ! not resolvable'))
    137137        #     status=False
    138         # if resolution['RESOLVED']:
    139         #     msg.append(self.make_result(result=resolution['RESOLVED'],msg='Ok ! it\'s resolvable'))
    140         #     if resolution['UNREACHABLE']:
    141         #         msg.append(self.make_result(result=resolution['UNREACHABLE'],msg='Nok ! not reachable'))
     138        # if resolution[u'RESOLVED']:
     139        #     msg.append(self.make_result(result=resolution[u'RESOLVED'],msg=u'Ok ! it\'s resolvable'))
     140        #     if resolution[u'UNREACHABLE']:
     141        #         msg.append(self.make_result(result=resolution[u'UNREACHABLE'],msg=u'Nok ! not reachable'))
    142142        #         status=False
    143143        #     else:
    144         #         msg.append(self.make_result(result=resolution['REACHABLE'],msg='Ok! it\'s reachable'))
     144        #         msg.append(self.make_result(result=resolution[u'REACHABLE'],msg=u'Ok! it\'s reachable'))
    145145
    146         #msg=''.join(msg)
    147         #output={'LLXNETWORK_TEST':{'status':status,'msg':msg}}
     146        #msg=u''.join(msg)
     147        #output={u'LLXNETWORK_TEST':{u'status':status,u'msg':msg}}
    148148        output={}
    149         output['NETINFO']=netinfo
     149        output[u'NETINFO']=netinfo
    150150        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxnfs.py

    r6399 r6450  
    44import os.path
    55
    6 log.debug("File "+__name__+" loaded")
     6log.debug(u'File '+__name__+u' loaded')
    77
    88class LlxNfs(Detector):
    9     _NEEDS = ['HELPER_UNCOMMENT','HELPER_EXECUTE']
    10     _PROVIDES = ['NFS_INFO']
     9    _NEEDS = [u'HELPER_UNCOMMENT',u'HELPER_EXECUTE']
     10    _PROVIDES = [u'NFS_INFO']
    1111
    1212    def check_exports(self,*args,**kwargs):
    1313        files=[]
    14         if os.path.isfile('/etc/exports'):
    15             files.append('/etc/exports')
     14        if os.path.isfile(u'/etc/exports'):
     15            files.append(u'/etc/exports')
    1616
    17         if os.path.isdir('/etc/exports.d'):
    18             for file in os.listdir('/etc/exports.d/'):
    19                 files.append('/etc/exports.d/'+file)
     17        if os.path.isdir(u'/etc/exports.d'):
     18            for file in os.listdir(u'/etc/exports.d/'):
     19                files.append(u'/etc/exports.d/'+file)
    2020        content=[]
    2121        for file in files:
    22             with open(file,'r') as f:
     22            with open(file,u'r') as f:
    2323                content.extend(self.uncomment(f.read()))
    2424        if content:
    25             content='\n'.join(content)
     25            content=u'\n'.join(content)
    2626        else:
    2727            content= None
    28         exported = self.execute(run='showmount -e --no-headers',stderr=None)
     28        exported = self.execute(run=u'showmount -e --no-headers',stderr=None)
    2929        if exported:
    30             exported = exported.split("\n")
     30            exported = exported.split(u'\n')
    3131        else:
    3232            exported=None
    3333
    34         return {'FILES':files,'CONTENT':content,'EXPORTED':exported}
     34        return {u'FILES':files,u'CONTENT':content,u'EXPORTED':exported}
    3535
    3636
    3737    def run(self,*args,**kwargs):
    38         output ={'NFS_INFO':'OK'}
     38        output ={u'NFS_INFO':u'OK'}
    3939        output.update(self.check_exports())
    4040        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxprocess.py

    r6441 r6450  
    44import re
    55
    6 log.debug("File "+__name__+" loaded")
     6log.debug(u'File '+__name__+u' loaded')
    77
    88# class Object(object):
    99#     def search(self,*args,**kwargs):
    10 #         f=lambda n: [ x for x in self.output if n in x['FULL_CMD']]
     10#         f=lambda n: [ x for x in self.output if n in x[u'FULL_CMD']]
    1111#         l=[]
    1212#         for x in args:
     
    2727class LlxProcess(Detector):
    2828
    29     _PROVIDES = ['PROCESS_INFO','HELPER_SEARCH_PROCESS','PROCESS_INFO_RAW']
    30     _NEEDS = ['HELPER_EXECUTE']
     29    _PROVIDES = [u'PROCESS_INFO',u'HELPER_SEARCH_PROCESS',u'PROCESS_INFO_RAW']
     30    _NEEDS = [u'HELPER_EXECUTE']
    3131
    3232    def search_process(self,*args,**kwargs):
    3333        plist=args[0]
    34         f=lambda n: [ x for x in plist if n in x['FULL_CMD']]
     34        f=lambda n: [ x for x in plist if n in x[u'FULL_CMD']]
    3535        l=[]
    3636        for x in args[1:]:
     
    5151        output=[]
    5252
    53         psout=self.execute(run='ps --no-headers -Awwo pid,euid,egid,args')
     53        psout=self.execute(run=u'ps --no-headers -Awwo pid,euid,egid,args')
    5454        regexp=re.compile(r'(?P<PID>\d+)\s+(?P<EUID>\d+)\s+(?P<EGID>\d+)\s+(?P<FULL_CMD>.*)$',re.UNICODE)
    55         for line in psout.split("\n"):
     55        for line in psout.split(u'\n'):
    5656            m=re.search(regexp,line)
    5757            if m:
     
    6161        #o.output=output
    6262
    63         return {'PROCESS_INFO': output, 'PROCESS_INFO_RAW':psout,'HELPER_SEARCH_PROCESS': {'code':self.search_process,'glob':globals()}}
     63        return {u'PROCESS_INFO': output, u'PROCESS_INFO_RAW':psout,u'HELPER_SEARCH_PROCESS': {u'code':self.search_process,u'glob':globals()}}
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxservices.py

    r6399 r6450  
    77
    88
    9 log.debug("File "+__name__+" loaded")
     9log.debug(u'File '+__name__+u' loaded')
    1010
    1111class LlxServices(Detector):
    12     _PROVIDES = ['SYSTEMCTL_INFO','APACHE_INFO','EPOPTES_INFO','DNSMASQ_INFO','SQUID_INFO','SAMBA_INFO']
    13     _NEEDS = ['HELPER_EXECUTE','DPKG_INFO','N4D_STATUS','N4D_MODULES','HELPER_UNCOMMENT','NETINFO','HELPER_COMPRESS_FILE','HELPER_COMPACT_FILES','HELPER_FILE_FIND_LINE']
     12    _PROVIDES = [u'SYSTEMCTL_INFO',u'APACHE_INFO',u'EPOPTES_INFO',u'DNSMASQ_INFO',u'SQUID_INFO',u'SAMBA_INFO']
     13    _NEEDS = [u'HELPER_EXECUTE',u'DPKG_INFO',u'N4D_STATUS',u'N4D_MODULES',u'HELPER_UNCOMMENT',u'NETINFO',u'HELPER_COMPRESS_FILE',u'HELPER_COMPACT_FILES',u'HELPER_FILE_FIND_LINE']
    1414
    1515    def run(self,*args,**kwargs):
    1616        output={}
    17         dpkg_info=kwargs['DPKG_INFO']
    18         netinfo=kwargs['NETINFO']
     17        dpkg_info=kwargs[u'DPKG_INFO']
     18        netinfo=kwargs[u'NETINFO']
    1919
    2020        has_apache=False
    21         if [ x for x in dpkg_info['BYNAME'].keys() if x.lower().startswith('apache2') ]:
     21        if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower().startswith(u'apache2') ]:
    2222            has_apache=True
    2323
    2424
    2525        # SYSTEMCTL
    26         sysctl_out=self.execute(run='systemctl --plain --no-legend --no-pager list-units --all -t service')
    27         info={'BYUNIT':{},'BYLOAD':{},'BYACTIVE':{},'BYSUB':{},'RAW':sysctl_out}
     26        sysctl_out=self.execute(run=u'systemctl --plain --no-legend --no-pager list-units --all -t service')
     27        info={u'BYUNIT':{},u'BYLOAD':{},u'BYACTIVE':{},u'BYSUB':{},u'RAW':sysctl_out}
    2828        regexp=re.compile(r'(?P<UNIT>[\w\-@]+).service\s+(?P<LOAD>\S+)\s+(?P<ACTIVE>\S+)\s+(?P<SUB>\S+)\s+(?P<NAME>.*$)')
    29         for line in sysctl_out.split('\n'):
     29        for line in sysctl_out.split(u'\n'):
    3030            service_info=re.search(regexp,line)
    3131            if service_info:
    3232                d=service_info.groupdict()
    33                 for x in ['UNIT','LOAD','ACTIVE','SUB']:
    34                     if d[x] in info['BY'+x]:
    35                         info['BY'+x][d[x]].append(d)
     33                for x in [u'UNIT',u'LOAD',u'ACTIVE',u'SUB']:
     34                    if d[x] in info[u'BY'+x]:
     35                        info[u'BY'+x][d[x]].append(d)
    3636                    else:
    37                         info['BY'+x][d[x]]=[d]
     37                        info[u'BY'+x][d[x]]=[d]
    3838
    39         output.update({'SYSTEMCTL_INFO':info})
     39        output.update({u'SYSTEMCTL_INFO':info})
    4040
    4141        # APACHE
    42         output.update({'APACHE_INFO':None})
     42        output.update({u'APACHE_INFO':None})
    4343
    4444        if has_apache:
    45             #apacheconf=''
    46             #files=['/etc/apache2/apache2.conf','/etc/apache2/envvars','/etc/apache2/ports.conf']
    47             #dirs=['/etc/apache2/conf-enabled/','/etc/apache2/mods-enabled/','/etc/apache2/sites-enabled/']
     45            #apacheconf=u''
     46            #files=[u'/etc/apache2/apache2.conf',u'/etc/apache2/envvars',u'/etc/apache2/ports.conf']
     47            #dirs=[u'/etc/apache2/conf-enabled/',u'/etc/apache2/mods-enabled/',u'/etc/apache2/sites-enabled/']
    4848            # for dir in dirs:
    4949            #     if os.path.exists(dir):
    5050            #         for file in os.listdir(dir):
    51             #             files.append(dir+'/'+file)
     51            #             files.append(dir+u'/'+file)
    5252            # for file in files:
    5353            #     if os.path.exists(file):
    54             #         with open(file,'r') as f:
    55             #             apacheconf+=f.read()+"\n"
     54            #         with open(file,u'r') as f:
     55            #             apacheconf+=f.read()+u'\n'
    5656            #apacheconf=self.uncomment(apacheconf)
    57             apacheconf=self.compact_files(path=['/etc/apache2/apache2.conf','/etc/apache2/envvars','/etc/apache2/ports.conf','/etc/apache2/conf-enabled/','/etc/apache2/mods-enabled/','/etc/apache2/sites-enabled/'])
     57            apacheconf=self.compact_files(path=[u'/etc/apache2/apache2.conf',u'/etc/apache2/envvars',u'/etc/apache2/ports.conf',u'/etc/apache2/conf-enabled/',u'/etc/apache2/mods-enabled/',u'/etc/apache2/sites-enabled/'])
    5858            try:
    59                 syntax=self.execute(run='apachectl -t',stderr='stdout')
    60                 if 'syntax ok' in syntax.lower():
    61                     syntax = 'OK'
    62                 mod=self.execute(run='apachectl -M -S',stderr=None).split("\n")
     59                syntax=self.execute(run=u'apachectl -t',stderr=u'stdout')
     60                if u'syntax ok' in syntax.lower():
     61                    syntax = u'OK'
     62                mod=self.execute(run=u'apachectl -M -S',stderr=None).split(u'\n')
    6363                modules={}
    6464                ports_used={}
     
    6969                    if m:
    7070                        d=m.groupdict()
    71                         modules.update({d['module']:d['type']})
     71                        modules.update({d[u'module']:d[u'type']})
    7272                    m = re.search(regexp2,line)
    7373                    if m:
     
    7676                port_in_use=False
    7777                # TODO: CHECK PROCESS NAME FROM PORT
    78                 if '80' in netinfo['netstat']['BYPORT']:
     78                if u'80' in netinfo[u'netstat'][u'BYPORT']:
    7979                    port_in_use=True
    80                 output.update({'APACHE_INFO':{'config':apacheconf,'syntax':syntax,'modules':modules,'PORT_USED':port_in_use}})
     80                output.update({u'APACHE_INFO':{u'config':apacheconf,u'syntax':syntax,u'modules':modules,u'PORT_USED':port_in_use}})
    8181            except Exception as e:
    82                 output.update({'APACHE_INFO':None})
     82                output.update({u'APACHE_INFO':None})
    8383        # EPOPTES
    8484
    8585        epoptes_info=None
    8686        has_epoptes=False
    87         if [ x for x in dpkg_info['BYNAME'].keys() if x.lower().startswith('epoptes') ]:
     87        if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower().startswith(u'epoptes') ]:
    8888            has_epoptes=True
    8989        if has_epoptes:
    9090            epoptes_info={}
    9191            has_epoptes_server=False
    92             if [ x for x in dpkg_info['BYNAME'].keys() if x.lower().startswith('n4d-epoptes-server') ]:
     92            if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower().startswith(u'n4d-epoptes-server') ]:
    9393                has_epoptes_server=True
    9494            has_epoptes_client=False
    95             if [ x for x in dpkg_info['BYNAME'].keys() if x.lower().startswith('n4d-epoptes-client') ]:
     95            if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower().startswith(u'n4d-epoptes-client') ]:
    9696                has_epoptes_client=True
    9797
    9898            if has_epoptes_server:
    9999                port_in_use=False
    100                 if '2872' in netinfo['netstat']['BYPORT']:
     100                if u'2872' in netinfo[u'netstat'][u'BYPORT']:
    101101                    port_in_use=True
    102102                logfile = None
    103                 file='/var/log/epoptes.log'
     103                file=u'/var/log/epoptes.log'
    104104                if os.path.exists(file):
    105105                    logfile = self.compress_file(file=file)
    106                 epoptes_info={'logfile':logfile,'PORT_USED':port_in_use}
     106                epoptes_info={u'logfile':logfile,u'PORT_USED':port_in_use}
    107107
    108         output.update({'EPOPTES_INFO':epoptes_info})
     108        output.update({u'EPOPTES_INFO':epoptes_info})
    109109
    110110        # DNSMASQ
    111         output.update({'DNSMASQ_INFO':None})
     111        output.update({u'DNSMASQ_INFO':None})
    112112        has_dnsmasq=False
    113         if [ x for x in dpkg_info['BYNAME'].keys() if x.lower() == 'dnsmasq' ]:
     113        if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower() == u'dnsmasq' ]:
    114114            has_dnsmasq=True
    115115        if has_dnsmasq:
    116             main_conf=self.compact_files(path=['/etc/dnsmasq.conf','/etc/dnsmasq.d/'])
    117             lines=self.file_find_line(main_conf,'conf-dir','=','.+',multiple_result=True)
    118             paths=[line[0].split('=')[1].strip() for line in lines]
    119             content=main_conf+'\n'+self.compact_files(path=paths)
    120             output.update({'DNSMASQ_INFO':{'config':content}})
     116            main_conf=self.compact_files(path=[u'/etc/dnsmasq.conf',u'/etc/dnsmasq.d/'])
     117            lines=self.file_find_line(main_conf,u'conf-dir',u'=',u'.+',multiple_result=True)
     118            paths=[line[0].split(u'=')[1].strip() for line in lines]
     119            content=main_conf+u'\n'+self.compact_files(path=paths)
     120            output.update({u'DNSMASQ_INFO':{u'config':content}})
    121121
    122122        # SQUID
    123         output.setdefault('SQUID_INFO',None)
     123        output.setdefault(u'SQUID_INFO',None)
    124124        has_squid=False
    125         if [ x for x in dpkg_info['BYNAME'].keys() if x.lower().startswith('squid') ]:
     125        if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower().startswith(u'squid') ]:
    126126            has_squid=True
    127127        if has_squid:
    128             main_conf=self.uncomment('/etc/squid/squid.conf')
    129             lines=self.file_find_line(main_conf,'[^\.]+\.conf"$',multiple_result=True)
    130             files = [ re.findall(r'"(\S+)"',f[0])[0] for f in lines]
     128            main_conf=self.uncomment(u'/etc/squid/squid.conf')
     129            lines=self.file_find_line(main_conf,u'[^\.]+\.conf"$',multiple_result=True)
     130            files = [ re.findall(r'[\'\"](\S+)[\'\"]',f[0],re.UNICODE)[0] for f in lines]
    131131            file_contents={}
    132             file_contents.setdefault('/etc/squid/squid.conf',main_conf)
     132            file_contents.setdefault(u'/etc/squid/squid.conf',main_conf)
    133133            for file in files:
    134134                file_contents.setdefault(file,self.uncomment(file))
    135             output.update({'SQUID_INFO':{'config':file_contents}})
     135            output.update({u'SQUID_INFO':{u'config':file_contents}})
    136136
    137137        #SAMBA
    138         output.update({'SAMBA_INFO':None})
     138        output.update({u'SAMBA_INFO':None})
    139139        has_samba=False
    140         if [ x for x in dpkg_info['BYNAME'].keys() if x.lower() == 'samba' ]:
     140        if [ x for x in dpkg_info[u'BYNAME'].keys() if x.lower() == u'samba' ]:
    141141            has_samba=True
    142142        if has_samba:
    143             main_conf=self.uncomment('/etc/samba/smb.conf',comments=[';','#'])
    144             lines=self.file_find_line(main_conf,[['include','=','\S+']])
    145             paths=[line[0].split('=')[1].strip() for line in lines]
     143            main_conf=self.uncomment(u'/etc/samba/smb.conf',comments=[u';',u'#'])
     144            lines=self.file_find_line(main_conf,[[u'include',u'=',u'\S+']])
     145            paths=[line[0].split(u'=')[1].strip() for line in lines]
    146146            content=main_conf+'\n'+self.compact_files(path=paths)
    147             resources_local=self.execute(run='smbclient -L localhost -N -g',stderr=None)
    148             resources_server=self.execute(run='smbclient -L server -N -g',stderr=None)
    149             output.update({'SAMBA_INFO':{'config':content,'resources_local':resources_local,'resources_server':resources_server}})
     147            resources_local=self.execute(run=u'smbclient -L localhost -N -g',stderr=None)
     148            resources_server=self.execute(run=u'smbclient -L server -N -g',stderr=None)
     149            output.update({u'SAMBA_INFO':{u'config':content,u'resources_local':resources_local,u'resources_server':resources_server}})
    150150
    151151        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxsysteminfo.py

    r6441 r6450  
    88import zlib
    99
    10 log.debug("File "+__name__+" loaded")
     10log.debug(u'File '+__name__+u' loaded')
    1111
    1212class LlxSystemInfo(Detector):
    13     _NEEDS=['HELPER_EXECUTE','HELPER_COMPRESS_FILE','HELPER_LIST_FILES','HELPER_UNCOMMENT']
    14     _PROVIDES=['LSHW_INFO','DMESG_INFO','VARLOG_INFO','LSUSB_INFO','DMESG_JOURNAL_INFO','SYSCTL_INFO','PAM_INFO','SUDO_INFO','ALTERNATIVES_INFO','ENVIRONMENT']
     13    _NEEDS=[u'HELPER_EXECUTE',u'HELPER_COMPRESS_FILE',u'HELPER_LIST_FILES',u'HELPER_UNCOMMENT']
     14    _PROVIDES=[u'LSHW_INFO',u'DMESG_INFO',u'VARLOG_INFO',u'LSUSB_INFO',u'DMESG_JOURNAL_INFO',u'SYSCTL_INFO',u'PAM_INFO',u'SUDO_INFO',u'ALTERNATIVES_INFO',u'ENVIRONMENT']
    1515
    1616    def get_lshw(self,*args,**kwargs):
    1717        try:
    18             lsusb=json.loads(self.execute(run='lshw -json',stderr=None))
    19             return {'JSON':lsusb,'RAW':self.execute(run='lshw',stderr=None)}
     18            lsusb=json.loads(self.execute(run=u'lshw -json',stderr=None))
     19            return {u'JSON':lsusb,u'RAW':self.execute(run=u'lshw',stderr=None)}
    2020        except Exception as e:
    2121            return None
     
    2323    def get_dmesg(self,*args,**kwargs):
    2424        try:
    25             dmesg=self.execute(run='journalctl --dmesg --no-pager --reverse --since today',stderr=None)
     25            dmesg=self.execute(run=u'journalctl --dmesg --no-pager --reverse --since today',stderr=None)
    2626            return dmesg
    2727        except Exception as e:
     
    3030    def get_dmesg2(self,*args,**kwargs):
    3131        try:
    32             dmesg=self.execute(run='dmesg',stderr=None)
     32            dmesg=self.execute(run=u'dmesg',stderr=None)
    3333            return dmesg
    3434        except Exception as e:
     
    4141
    4242        try:
    43             #prefix='/var/log'
     43            #prefix=u'/var/log'
    4444            #file_names=[]
    4545            #for root,dirnames,filenames in os.walk(prefix):
    4646            #    for filename in filter(filenames):
    4747            #        file_names.append(os.path.join(root,filename))
    48             file_names=self.list_files(path='/var/log',regexp=regexp)
    49             exceptions=['/var/log/lastlog','/var/log/wtmp','/var/log/wtmp.1']
     48            file_names=self.list_files(path=u'/var/log',regexp=regexp)
     49            exceptions=[u'/var/log/lastlog',u'/var/log/wtmp',u'/var/log/wtmp.1']
    5050            file_names=[ x for x in file_names if x not in exceptions]
    5151            for file in file_names:
     
    5454                    varlog[file]=comp
    5555                else:
    56                     log.warning('Fail compressing logfile {}'.format(file))
     56                    log.warning(u'Fail compressing logfile {}'.format(file))
    5757        except Exception as e:
    58             return None
     58            pass
    5959        return varlog
    6060
     
    6262        lsusb={}
    6363        try:
    64             lsusb=self.execute(run='lsusb',stderr=None)
     64            lsusb=self.execute(run=u'lsusb',stderr=None)
    6565            return lsusb
    6666        except Exception as e:
     
    7575                return d.setdefault(l[0],value)
    7676        d={}
    77         raw_info=self.execute(run='sysctl -a',stderr=None)
     77        raw_info=self.execute(run=u'sysctl -a',stderr=None)
    7878        if raw_info:
    79             for key_value in raw_info.split('\n'):
    80                 key,value=key_value.split(' = ')
    81                 make_hierarchy(d,key.split('.'),value)
    82         d.setdefault('RAW',raw_info)
     79            for key_value in raw_info.split(u'\n'):
     80                key,value=key_value.split(u' = ')
     81                make_hierarchy(d,key.split(u'.'),value)
     82        d.setdefault(u'RAW',raw_info)
    8383        return d
    8484
    8585    def get_pams(self,*args,**kwargs):
    86         files=self.list_files(path=['/etc/pam.conf','/etc/pam.d/','/usr/share/pam-configs/'])
     86        files=self.list_files(path=[u'/etc/pam.conf',u'/etc/pam.d/',u'/usr/share/pam-configs/'])
    8787        d={}
    8888        for file in files:
     
    9191
    9292    def get_sudoers(self,*args,**kwargs):
    93         files=self.list_files(path=['/etc/sudoers','/etc/sudoers.d/'])
     93        files=self.list_files(path=[u'/etc/sudoers',u'/etc/sudoers.d/'])
    9494        d={}
    9595        for file in files:
     
    9898
    9999    def get_alternatives(self,*args,**kwargs):
    100         return self.execute(run='update-alternatives --get-selections')
     100        return self.execute(run=u'update-alternatives --get-selections')
    101101
    102102    def run(self,*args,**kwargs):
    103         output={'LSHW_INFO':{},'DMESG_INFO':{},'SYSLOG_INFO':{},'LSUSB_INFO':{}}
     103        output={u'LSHW_INFO':{},u'DMESG_INFO':{},u'SYSLOG_INFO':{},u'LSUSB_INFO':{}}
    104104
    105         output['LSHW_INFO']=self.get_lshw()
    106         output['DMESG_INFO']=self.get_dmesg2()
    107         output['DMESG_JOURNAL_INFO']=self.get_dmesg()
    108         output['VARLOG_INFO']=self.get_varlog()
    109         output['LSUSB_INFO']=self.get_lsusb()
    110         output['SYSCTL_INFO']=self.get_sysctl()
    111         output['PAM_INFO']=self.get_pams()
    112         output['SUDO_INFO']=self.get_sudoers()
    113         output['ALTERNATIVES_INFO']=self.get_alternatives()
    114         output['ENVIRONMENT']=dict(os.environ)
     105        output[u'LSHW_INFO']=self.get_lshw()
     106        output[u'DMESG_INFO']=self.get_dmesg2()
     107        output[u'DMESG_JOURNAL_INFO']=self.get_dmesg()
     108        output[u'VARLOG_INFO']=self.get_varlog()
     109        output[u'LSUSB_INFO']=self.get_lsusb()
     110        output[u'SYSCTL_INFO']=self.get_sysctl()
     111        output[u'PAM_INFO']=self.get_pams()
     112        output[u'SUDO_INFO']=self.get_sudoers()
     113        output[u'ALTERNATIVES_INFO']=self.get_alternatives()
     114        output[u'ENVIRONMENT']=dict(os.environ)
    115115        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxsystemsw.py

    r6441 r6450  
    55
    66
    7 log.debug("File "+__name__+" loaded")
     7log.debug(u'File '+__name__+u' loaded')
    88
    99class LlxSystemSW(Detector):
    10     _PROVIDES = ['DPKG_INFO','APT_SOURCES','LLIUREX_TIMESTAMP']
    11     _NEEDS = ['HELPER_EXECUTE','HELPER_COMPACT_FILES']
     10    _PROVIDES = [u'DPKG_INFO',u'APT_SOURCES',u'LLIUREX_TIMESTAMP']
     11    _NEEDS = [u'HELPER_EXECUTE',u'HELPER_COMPACT_FILES']
    1212
    1313    def run(self,*args,**kwargs):
    1414        output={}
    15         pkg_list=self.execute(run='dpkg -l',stderr=None).strip("\n")
    16         dpkg_info={'BYNAME':{},'BYSTATUS':{}}
     15        pkg_list=self.execute(run=u'dpkg -l',stderr=None).strip(u'\n')
     16        dpkg_info={u'BYNAME':{},u'BYSTATUS':{}}
    1717        regexp=re.compile(r'^(?P<STATUS>\w+)\s+(?P<PACKAGE>[^:\s]+)(:(?P<PACKAGE_ARCHITECTURE>\S+))?\s+(?P<VERSION>\S+)\s+(?P<BUILD_ARCHITECTURE>\S+)\s+(?P<DESCRIPTION>.*)$',re.UNICODE)
    18         for line in pkg_list.split("\n"):
     18        for line in pkg_list.split(u'\n'):
    1919            pkg_info=re.search(regexp,line)
    2020            if pkg_info:
    2121                d=pkg_info.groupdict()
    22                 if d['PACKAGE_ARCHITECTURE'] == None:
    23                     d['PACKAGE_ARCHITECTURE'] = d['BUILD_ARCHITECTURE']
    24                 name = d['PACKAGE']
    25                 status = d['STATUS']
    26                 del d['PACKAGE']
    27                 dpkg_info['BYNAME'].setdefault(name,[])
    28                 dpkg_info['BYNAME'][name].append(d.copy())
    29                 d['NAME']=name
    30                 del d['STATUS']
    31                 dpkg_info['BYSTATUS'].setdefault(status,{})
    32                 dpkg_info['BYSTATUS'][status].setdefault(name,[])
    33                 dpkg_info['BYSTATUS'][status][name].append(d)
     22                if d[u'PACKAGE_ARCHITECTURE'] == None:
     23                    d[u'PACKAGE_ARCHITECTURE'] = d[u'BUILD_ARCHITECTURE']
     24                name = d[u'PACKAGE']
     25                status = d[u'STATUS']
     26                del d[u'PACKAGE']
     27                dpkg_info[u'BYNAME'].setdefault(name,[])
     28                dpkg_info[u'BYNAME'][name].append(d.copy())
     29                d[u'NAME']=name
     30                del d[u'STATUS']
     31                dpkg_info[u'BYSTATUS'].setdefault(status,{})
     32                dpkg_info[u'BYSTATUS'][status].setdefault(name,[])
     33                dpkg_info[u'BYSTATUS'][status][name].append(d)
    3434
    3535
    36         output.update({'DPKG_INFO':dpkg_info})
    37         output['DPKG_INFO'].setdefault('RAW',pkg_list)
    38         output.update({'APT_SOURCES':self.compact_files(path=['/etc/apt/sources.list','/etc/apt/sources.list.d/'],regexp=r'[^\.]+\.list$')})
     36        output.update({u'DPKG_INFO':dpkg_info})
     37        output[u'DPKG_INFO'].setdefault(u'RAW',pkg_list)
     38        output.update({u'APT_SOURCES':self.compact_files(path=[u'/etc/apt/sources.list',u'/etc/apt/sources.list.d/'],regexp=r'[^\.]+\.list$')})
    3939        try:
    40             output.update({'LLIUREX_TIMESTAMP':dpkg_info['BYNAME']['lliurex-version-timestamp'][0]['VERSION']})
     40            output.update({u'LLIUREX_TIMESTAMP':dpkg_info[u'BYNAME'][u'lliurex-version-timestamp'][0][u'VERSION']})
    4141        except:
    42             output.update({'LLIUREX_TIMESTAMP':'NOT_AVAILABLE'})
     42            output.update({u'LLIUREX_TIMESTAMP':u'NOT_AVAILABLE'})
    4343        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxsystemtest.py

    r6420 r6450  
    33import hwdetector.utils.log as log
    44
    5 log.debug("File "+__name__+" loaded")
     5log.debug(u'File '+__name__+u' loaded')
    66
    77class LlxSystemTest(Detector):
    8     _NEEDS=['LLIUREX_RELEASE','SYSTEMCTL_INFO','DPKG_INFO','APACHE_INFO','EPOPTES_INFO','DNSMASQ_INFO','SQUID_INFO','PROCESS_INFO','VARLOG_INFO','HELPER_SEARCH_PROCESS']
    9     _PROVIDES=['LLXSYSTEM_TEST']
     8    _NEEDS=[u'LLIUREX_RELEASE',u'SYSTEMCTL_INFO',u'DPKG_INFO',u'APACHE_INFO',u'EPOPTES_INFO',u'DNSMASQ_INFO',u'SQUID_INFO',u'PROCESS_INFO',u'VARLOG_INFO',u'HELPER_SEARCH_PROCESS']
     9    _PROVIDES=[u'LLXSYSTEM_TEST']
    1010
    1111    def make_result(self,*args,**kwargs):
    12         ret=''
    13         if not ('result' in kwargs and 'msg' in kwargs):
     12        ret=u''
     13        if not (u'result' in kwargs and u'msg' in kwargs):
    1414            return
    15         if isinstance(kwargs['result'],list):
    16             result=kwargs['result']
     15        if isinstance(kwargs[u'result'],list):
     16            result=kwargs[u'result']
    1717        else:
    18             result=[str(kwargs['result'])]
     18            result=[unicode(kwargs[u'result'])]
    1919
    2020        for x in result:
    21             ret+='{}> {}: {}\n'.format(self.__class__.__name__,x,kwargs['msg'])
     21            ret+=u'{}> {}: {}\n'.format(self.__class__.__name__,x,kwargs[u'msg'])
    2222        return ret
    2323
    2424    def run(self,*args,**kwargs):
    2525
    26         release=str(kwargs['LLIUREX_RELEASE'])
     26        release=unicode(kwargs[u'LLIUREX_RELEASE'])
    2727        status=True
    2828        msg=[]
    2929
    30         systemctl=kwargs['SYSTEMCTL_INFO']
     30        systemctl=kwargs[u'SYSTEMCTL_INFO']
    3131        needed_services={}
    32         needed_services_common=[{'n4d':['n4d-server']}]
     32        needed_services_common=[{u'n4d':[u'n4d-server']}]
    3333
    3434        map(needed_services.update,needed_services_common)
    3535
    36         if 'server' in release.lower():
    37             map(needed_services.update,[{'apache2':['apache2']},{'epoptes':['epoptes','socat']},{'dnsmasq':['dnsmasq']},{'slapd':['slapd']}])
     36        if u'server' in release.lower():
     37            map(needed_services.update,[{u'apache2':[u'apache2']},{u'epoptes':[u'epoptes',u'socat']},{u'dnsmasq':[u'dnsmasq']},{u'slapd':[u'slapd']}])
    3838
    3939        res_ok=[]
    4040        res_nok=[]
    41         ps=kwargs['PROCESS_INFO']
     41        ps=kwargs[u'PROCESS_INFO']
    4242        for need in needed_services:
    43             if need in systemctl['BYUNIT'] and systemctl['BYUNIT'][need][0]['SUB'] == 'running':
    44                 res_ok.append('Service {}'.format(need))
     43            if need in systemctl[u'BYUNIT'] and systemctl[u'BYUNIT'][need][0][u'SUB'] == u'running':
     44                res_ok.append(u'Service {}'.format(need))
    4545                plist=self.search_process(needed_services[need])
    4646                for x in plist:
    47                     res_ok.append('{} Process matching \'{}\''.format(len(plist[x]),x))
     47                    res_ok.append(u'{} Process matching \'{}\''.format(len(plist[x]),x))
    4848            else:
    49                 res_nok.append('Service {}'.format(need))
     49                res_nok.append(u'Service {}'.format(need))
    5050                status=False
    5151
    5252
    53         msg.append(self.make_result(result=res_ok,msg='Ok! Running'))
    54         msg.append(self.make_result(result=res_nok,msg='Nok! Down'))
     53        msg.append(self.make_result(result=res_ok,msg=u'Ok! Running'))
     54        msg.append(self.make_result(result=res_nok,msg=u'Nok! Down'))
    5555
    56         msg=''.join(msg)
    57         output={'LLXSYSTEM_TEST':{'status':status,'msg':msg}}
     56        msg=u''.join(msg)
     57        output={u'LLXSYSTEM_TEST':{u'status':status,u'msg':msg}}
    5858        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxtest.py

    r6399 r6450  
    55import subprocess
    66
    7 log.debug("File "+__name__+" loaded")
     7log.debug(u'File '+__name__+u' loaded')
    88
    99class CTest(object):
     
    1717    def toString(self,*args,**kwargs):
    1818        status=True
    19         if 'range' in kwargs:
    20             range_val=int(kwargs['range'])
     19        if u'range' in kwargs:
     20            range_val=int(kwargs[u'range'])
    2121            self.attrib=range(range_val)
    2222            status=False
     
    4343class LlxTest(Detector):
    4444
    45     #_PROVIDES = ['TEST','HELPER_ECHO']
    46     _PROVIDES = ['TEST']
     45    #_PROVIDES = [u'TEST',u'HELPER_ECHO']
     46    _PROVIDES = [u'TEST']
    4747    _NEEDS = []
    4848
    4949    # def echo(*args,**kwargs):
    5050    #     c=0
    51     #     o=subprocess.check_output(['ls'])
     51    #     o=subprocess.check_output([u'ls'])
    5252    #     for x in args:
    5353    #         c = c + x
     
    5656
    5757    def run(self,*args,**kwargs):
    58         #param=kwargs['NETINFO'].upper().replace('NULL','null')
     58        #param=kwargs[u'NETINFO'].upper().replace(u'NULL',u'null')
    5959        #netinfo=json.loads(param)
    6060        #netinfo2=param
    6161        #e = self.echo
    62         #return {'TEST':netinfo['LO'],'HELPER_ECHO': {'code':e,'glob':globals()}}
     62        #return {u'TEST':netinfo[u'LO'],u'HELPER_ECHO': {u'code':e,u'glob':globals()}}
    6363        #t=CTest(5)
    64         #return {'TEST':  t}
     64        #return {u'TEST':  t}
    6565        ####t=DetectorObject()
    66         ####setattr(t,'attrib',range(10))
     66        ####setattr(t,u'attrib',range(10))
    6767        #t.attrib=range(10)
    6868        ####t.to_string = toString2
    69         return {'TEST':''}
     69        return {u'TEST':u''}
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxtests.py

    r6399 r6450  
    44import sys
    55
    6 log.debug("File "+__name__+" loaded")
     6log.debug(u'File '+__name__+u' loaded')
    77
    88class LlxAlltests(Detector):
    9     _NEEDS=['LLXSYSTEM_TEST','LLXNETWORK_TEST','LLXUSERS_TEST']
    10     _PROVIDES=['ALL_TESTS']
     9    _NEEDS=[u'LLXSYSTEM_TEST',u'LLXNETWORK_TEST',u'LLXUSERS_TEST']
     10    _PROVIDES=[u'ALL_TESTS']
    1111
    1212    def run(self,*args,**kwargs):
    1313        ret=True
    1414        for test in self._NEEDS:
    15             if kwargs[test]['status']:
     15            if kwargs[test][u'status']:
    1616                pass
    17                 #sys.stderr.write("{}>>>Testing {} was OK!\n".format(kwargs[test]['msg'],test))
     17                #sys.stderr.write(u'{}>>>Testing {} was OK!\n'.format(kwargs[test][u'msg'],test))
    1818            else:
    1919                pass
    20                 #sys.stderr.write("{}>>>Testing {} was Failed!\n".format(kwargs[test]['msg'],test))
     20                #sys.stderr.write(u'{}>>>Testing {} was Failed!\n'.format(kwargs[test][u'msg'],test))
    2121                ret=False
    22         output={'ALL_TESTS':ret}
     22        output={u'ALL_TESTS':ret}
    2323        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxtime.py

    r6399 r6450  
    44import re
    55
    6 log.debug("File "+__name__+" loaded")
     6log.debug(u'File '+__name__+u' loaded')
    77
    88class LlxTime(Detector):
    99
    10     _PROVIDES = ['TIME','NTP_INFO']
    11     _NEEDS = ["HELPER_UNCOMMENT","HELPER_EXECUTE"]
     10    _PROVIDES = [u'TIME',u'NTP_INFO']
     11    _NEEDS = [u'HELPER_UNCOMMENT',u'HELPER_EXECUTE']
    1212
    1313    def run(self,*args,**kwargs):
    1414        output={}
    1515
    16         timedatectl=self.execute(run='timedatectl',stderr=None)
     16        timedatectl=self.execute(run=u'timedatectl',stderr=None)
    1717
    1818        m=re.search(r'Local time:\s\w+ (?P<TIMESW>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\s\w+)',timedatectl)
     
    3434        synced = False
    3535        try:
    36             ntp_st = self.execute(run="ntpq -pn", stderr=None)
    37             for line in ntp_st.split("\n"):
     36            ntp_st = self.execute(run=u'ntpq -pn', stderr=None)
     37            for line in ntp_st.split(u'\n'):
    3838                m = re.search(r'^\*(?P<SYNCSERVER>\d+\.\d+\.\d+\.\d+)', line)
    3939                if m:
    40                     if output['NTPENABLED'] == 'yes' and output['NTPSYNC'] == 'yes':
     40                    if output[u'NTPENABLED'] == u'yes' and output[u'NTPSYNC'] == u'yes':
    4141                        synced = True
    4242                        output.update(m.groupdict())
    4343                        break
    4444        except Exception as e:
    45             ntp_st = str(e)
     45            ntp_st = unicode(e)
    4646
    47         return {'TIME':output,'NTP_INFO':{'STATE':{'synced':synced,'status':ntp_st.strip()},'CONFIG':self.uncomment('/etc/ntp.conf')}}
     47        return {u'TIME':output,u'NTP_INFO':{u'STATE':{u'synced':synced,u'status':ntp_st.strip()},u'CONFIG':self.uncomment(u'/etc/ntp.conf')}}
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxusers.py

    r6420 r6450  
    44import os
    55
    6 log.debug("File "+__name__+" loaded")
     6log.debug(u'File '+__name__+u' loaded')
    77
    88class LlxUsers(Detector):
    9     _NEEDS = ['HELPER_EXECUTE','HELPER_USERS_LOGGED','LDAP_INFO','MOUNTS_INFO','LLIUREX_SESSION_TYPE','LLIUREX_RELEASE','HELPER_WHO_I_AM','LOGIN_TYPE','LDAP_MODE','NFS_INITIALIZATION','ROOT_MODE']
    10     _PROVIDES = ['USERS_INFO','USER_TEST']
     9    _NEEDS = [u'HELPER_EXECUTE',u'HELPER_USERS_LOGGED',u'LDAP_INFO',u'MOUNTS_INFO',u'LLIUREX_SESSION_TYPE',u'LLIUREX_RELEASE',u'HELPER_WHO_I_AM',u'LOGIN_TYPE',u'LDAP_MODE',u'NFS_INITIALIZATION',u'ROOT_MODE']
     10    _PROVIDES = [u'USERS_INFO',u'USER_TEST']
    1111
    1212
    1313    def check_mounts(self,username,typeuser,*args,**kwargs):
    14         mounts_info=kwargs['MOUNTS_INFO']
    15         session_type = kwargs['LLIUREX_SESSION_TYPE'].upper()
    16         release = kwargs['LLIUREX_RELEASE'].lower()
    17         ldap_mode = kwargs['LDAP_MODE'].lower()
    18         nfs_server = kwargs['NFS_INITIALIZATION']
     14        mounts_info=kwargs[u'MOUNTS_INFO']
     15        session_type = kwargs[u'LLIUREX_SESSION_TYPE'].upper()
     16        release = kwargs[u'LLIUREX_RELEASE'].lower()
     17        ldap_mode = kwargs[u'LDAP_MODE'].lower()
     18        nfs_server = kwargs[u'NFS_INITIALIZATION']
    1919        ret = None
    2020        msg = []
    2121
    22         if release != 'server' and release != 'client':
    23             return (True,['Not in classroom model'])
     22        if release != u'server' and release != u'client':
     23            return (True,[u'Not in classroom model'])
    2424
    2525        def check_mount_network(username,shares,mounts_info):
     
    2727            ret = True
    2828            for share in shares:
    29                 mountpoint='/run/' + username + '/' + shares[share]
    30                 mountsource='//server/'+share
    31                 for x in mounts_info['NETWORK']:
     29                mountpoint=u'/run/' + username + u'/' + shares[share]
     30                mountsource=u'//server/'+share
     31                for x in mounts_info[u'NETWORK']:
    3232                    ret = False
    33                     if x['mount_point'] ==  mountpoint and x['mount_source'] == mountsource and x['fstype'] == 'cifs':
     33                    if x[u'mount_point'] ==  mountpoint and x[u'mount_source'] == mountsource and x[u'fstype'] == u'cifs':
    3434                        ret = True
    35                         msg.append('Samba share {} mounted under {}'.format(mountsource,mountpoint))
     35                        msg.append(u'Samba share {} mounted under {}'.format(mountsource,mountpoint))
    3636                        break
    3737                if not ret:
    38                     msgs.append('Samba share {} NOT mounted under {}'.format(mountsource,mountpoint))
     38                    msgs.append(u'Samba share {} NOT mounted under {}'.format(mountsource,mountpoint))
    3939                    break
    4040                else:
     
    4545            ret = True
    4646            for bind in bind_paths:
    47                 for x in mounts_info['BIND']:
     47                for x in mounts_info[u'BIND']:
    4848                    ret = False
    49                     if x['mount_point'].startswith('/home/' + username) and x['mount_source'] == bind_paths[bind]:
     49                    if x[u'mount_point'].startswith(u'/home/' + username) and x[u'mount_source'] == bind_paths[bind]:
    5050                        ret = True
    51                         msg.append('Bindmount {} from {} available'.format(x['mount_point'],bind_paths[bind]))
     51                        msg.append(u'Bindmount {} from {} available'.format(x[u'mount_point'],bind_paths[bind]))
    5252                        if nfs_server:
    53                             for x2 in mounts_info['NETWORK']:
     53                            for x2 in mounts_info[u'NETWORK']:
    5454                                ret2 = False
    55                                 if x2['devid'] == x['devid'] and x2['mount_source'].startswith(nfs_server):
     55                                if x2[u'devid'] == x[u'devid'] and x2[u'mount_source'].startswith(nfs_server):
    5656                                    ret2 = True
    57                                     msg.append('Referred share ({}) from bindmount ({}) is mounted from server ({})'.format(x2['mount_point'],x['mount_source'],nfs_server))
     57                                    msg.append(u'Referred share ({}) from bindmount ({}) is mounted from server ({})'.format(x2[u'mount_point'],x[u'mount_source'],nfs_server))
    5858                                    break
    5959                            if not ret2:
    60                                 msg.append('Referred share ({}) from bindmount ({}) NOT mounted from server ({})'.format(x2['mount_point'],x['mount_source'],nfs_server))
     60                                msg.append(u'Referred share ({}) from bindmount ({}) NOT mounted from server ({})'.format(x2[u'mount_point'],x[u'mount_source'],nfs_server))
    6161                                ret = False
    6262                                break
    6363                        else:
    6464                            ret2 = True
    65                             msg.append('Mounting from local without nfs, skipped checking')
     65                            msg.append(u'Mounting from local without nfs, skipped checking')
    6666
    6767                        break
    6868                if not ret:
    69                     msg.append('Bindmount {} from {} NOT available'.format(bind,bind_paths[bind]))
     69                    msg.append(u'Bindmount {} from {} NOT available'.format(bind,bind_paths[bind]))
    7070                    break
    7171
     
    7474        samba_shares = []
    7575        nfs_bind_paths = {}
    76         if typeuser == 'student':
    77             if release == 'server':
    78                 nfs_bind_paths={'Desktop':'/net/server-sync/home/students/'+username+'/Desktop','Documents':'/net/server-sync/home/students/'+username+'/Documents','share':'/net/server-sync/share','groups_share':'/net/server-sync/groups_share'}
    79             elif release == 'client':
    80                 if session_type != 'THIN':
    81                     samba_shares = {'home':'home','share':'share','groups_share':'groups_share'}
    82                 nfs_bind_paths={'Desktop':'/run/'+username+'/home/students/'+username+'/Desktop','Documents':'/run/'+username+'/home/students/'+username+'/Documents','share':'/run/'+username+'/share','groups_share':'/run/'+username+'/groups_share'}
    83         elif typeuser == 'teacher':
    84             if release == 'server':
    85                 nfs_bind_paths={'Desktop':'/net/server-sync/home/teachers/'+username+'/Desktop','Documents':'/net/server-sync/home/teachers/'+username+'/Documents','share':'/net/server-sync/share','groups_share':'/net/server-sync/groups_share','teachers_share':'/net/server-sync/teachers_share','/home/students':'/net/server-sync/home/students'}
    86             elif release == 'client':
    87                 if session_type != 'THIN':
    88                     samba_shares = {'home':'home','share':'share', 'groups_share':'groups_share', 'share_teachers':'teachers_share'}
    89                 nfs_bind_paths={'Desktop':'/run/'+username+'/home/teachers/'+username+'/Desktop','Documents':'/run/'+username+'/home/teachers/'+username+'/Documents','share':'/run/'+username+'/share','groups_share':'/run/'+username+'/groups_share','teachers_share':'/run/'+username+'/teachers_share','/home/students':'/run/'+username+'/home/students'}
    90         elif typeuser == 'admin':
    91             if release == 'server':
    92                 nfs_bind_paths={'Desktop':'/net/server-sync/home/admins/'+username+'/Desktop','Documents':'/net/server-sync/home/admins/'+username+'/Documents','share':'/net/server-sync/share','groups_share':'/net/server-sync/groups_share'}
    93             elif release == 'client':
    94                 if session_type != 'THIN':
    95                     samba_shares = {'home':'home','share':'share','groups_share':'groups_share','share_teachers':'teachers_share'}
    96                 nfs_bind_paths={'Desktop':'/run/'+username+'/home/admins/'+username+'/Desktop','Documents':'/run/'+username+'/home/admins/'+username+'/Documents','share':'/run/'+username+'/share','groups_share':'/run/'+username+'/groups_share'}
     76        if typeuser == u'student':
     77            if release == u'server':
     78                nfs_bind_paths={u'Desktop':u'/net/server-sync/home/students/'+username+u'/Desktop',u'Documents':u'/net/server-sync/home/students/'+username+u'/Documents',u'share':u'/net/server-sync/share',u'groups_share':u'/net/server-sync/groups_share'}
     79            elif release == u'client':
     80                if session_type != u'THIN':
     81                    samba_shares = {u'home':u'home',u'share':u'share',u'groups_share':u'groups_share'}
     82                nfs_bind_paths={u'Desktop':u'/run/'+username+u'/home/students/'+username+u'/Desktop',u'Documents':u'/run/'+username+u'/home/students/'+username+u'/Documents',u'share':u'/run/'+username+u'/share',u'groups_share':u'/run/'+username+u'/groups_share'}
     83        elif typeuser == u'teacher':
     84            if release == u'server':
     85                nfs_bind_paths={u'Desktop':u'/net/server-sync/home/teachers/'+username+u'/Desktop',u'Documents':u'/net/server-sync/home/teachers/'+username+u'/Documents',u'share':u'/net/server-sync/share',u'groups_share':u'/net/server-sync/groups_share',u'teachers_share':u'/net/server-sync/teachers_share',u'/home/students':u'/net/server-sync/home/students'}
     86            elif release == u'client':
     87                if session_type != u'THIN':
     88                    samba_shares = {u'home':u'home',u'share':u'share', u'groups_share':u'groups_share', u'share_teachers':u'teachers_share'}
     89                nfs_bind_paths={u'Desktop':u'/run/'+username+u'/home/teachers/'+username+u'/Desktop',u'Documents':u'/run/'+username+u'/home/teachers/'+username+u'/Documents',u'share':u'/run/'+username+u'/share',u'groups_share':u'/run/'+username+u'/groups_share',u'teachers_share':u'/run/'+username+u'/teachers_share',u'/home/students':u'/run/'+username+u'/home/students'}
     90        elif typeuser == u'admin':
     91            if release == u'server':
     92                nfs_bind_paths={u'Desktop':u'/net/server-sync/home/admins/'+username+u'/Desktop',u'Documents':u'/net/server-sync/home/admins/'+username+u'/Documents',u'share':u'/net/server-sync/share',u'groups_share':u'/net/server-sync/groups_share'}
     93            elif release == u'client':
     94                if session_type != u'THIN':
     95                    samba_shares = {u'home':u'home',u'share':u'share',u'groups_share':u'groups_share',u'share_teachers':u'teachers_share'}
     96                nfs_bind_paths={u'Desktop':u'/run/'+username+u'/home/admins/'+username+u'/Desktop',u'Documents':u'/run/'+username+u'/home/admins/'+username+u'/Documents',u'share':u'/run/'+username+u'/share',u'groups_share':u'/run/'+username+u'/groups_share'}
    9797
    9898        ret, msgs = check_mount_network(username,samba_shares,mounts_info)
     
    106106    def run(self,*args,**kwargs):
    107107        output={}
    108         LDAP_INFO=kwargs['LDAP_INFO']
    109         LLIUREX_RELEASE=str(kwargs['LLIUREX_RELEASE']).lower()
     108        LDAP_INFO=kwargs[u'LDAP_INFO']
     109        LLIUREX_RELEASE=unicode(kwargs[u'LLIUREX_RELEASE']).lower()
    110110        logged_users=self.users_logged()
    111111        myinfo=self.who_i_am()
    112112
    113113        try:
    114             people=LDAP_INFO['CONFIG']['DB']['net']['lliurex']['ma5']['People']
    115             users=[(x,people['Students'][x]) for x in people['Students'].keys() if isinstance(people['Students'][x],dict)]
    116             admins=[(x,people['Admins'][x]) for x in people['Admins'].keys() if isinstance(people['Admins'][x],dict)]
    117             teachers=[(x,people['Teachers'][x]) for x in people['Teachers'].keys() if isinstance(people['Teachers'][x],dict)]
     114            people=LDAP_INFO[u'CONFIG'][u'DB'][u'net'][u'lliurex'][u'ma5'][u'People']
     115            users=[(x,people[u'Students'][x]) for x in people[u'Students'].keys() if isinstance(people[u'Students'][x],dict)]
     116            admins=[(x,people[u'Admins'][x]) for x in people[u'Admins'].keys() if isinstance(people[u'Admins'][x],dict)]
     117            teachers=[(x,people[u'Teachers'][x]) for x in people[u'Teachers'].keys() if isinstance(people[u'Teachers'][x],dict)]
    118118        except Exception as e:
    119             log.warning('Fail getting needed ldap information, using fake information only for current user')
     119            log.warning(u'Fail getting needed ldap information, using fake information only for current user')
    120120            people = None # NO LDAP ACCESS DO IT ONLY FOR ME
    121             fake_ldap_info=(myinfo['name'],{'homeDirectory':[myinfo['user_info'][5]],'uid':[myinfo['name']]})
     121            fake_ldap_info=(myinfo[u'name'],{u'homeDirectory':[myinfo[u'user_info'][5]],u'uid':[myinfo[u'name']]})
    122122            users=[]
    123123            admins=[]
    124124            teachers=[]
    125             if kwargs['LOGIN_TYPE'].lower() == 'ldap':
    126                 if 'students' in myinfo['groups']:
    127                     users.append(fake_ldap_info)
    128                 elif 'teachers' in myinfo['groups']:
    129                     teachers.append(fake_ldap_info)
    130                 elif 'admins' in myinfo['groups']:
    131                     admins.append(fake_ldap_info)
     125            try:
     126                if unicode(kwargs[u'LOGIN_TYPE']).lower() == u'ldap':
     127                    if u'students' in myinfo[u'groups']:
     128                        users.append(fake_ldap_info)
     129                    elif u'teachers' in myinfo[u'groups']:
     130                        teachers.append(fake_ldap_info)
     131                    elif u'admins' in myinfo[u'groups']:
     132                        admins.append(fake_ldap_info)
     133            except Exception as e:
     134                log.error(e)
    132135
    133136
    134137        # USER TEST FUNCTIONALITY
    135138
    136         homes = ['/home/'+x for x in os.listdir('/home/')]
    137         cmd = ['getfacl','-tp'] + homes
    138         perm_info=self.execute(run=cmd,stderr=None).split("\n")
     139        homes = [u'/home/'+x for x in os.listdir(u'/home/')]
     140        cmd = [u'getfacl',u'-tp'] + homes
     141        perm_info=self.execute(run=cmd,stderr=None).split(u'\n')
    139142        perm_dirs={}
    140143        i=-1
     
    143146            i+=1
    144147            line=perm_info[i]
    145             if line.startswith('#'):
     148            if line.startswith(u'#'):
    146149                # complete previous if exists
    147150                if file:
    148                     if perm_dirs[file]['group'] or perm_dirs[file]['user']:
    149                         perm_dirs[file]['USE_ACLS']=True
    150                     else:
    151                         perm_dirs[file]['USE_ACLS'] =False
     151                    if perm_dirs[file][u'group'] or perm_dirs[file][u'user']:
     152                        perm_dirs[file][u'USE_ACLS']=True
     153                    else:
     154                        perm_dirs[file][u'USE_ACLS'] =False
    152155                file=line[8:]
    153                 perm_dirs[file]={'USER':{},'GROUP':{},'user':{},'group':{},'other':{},'mask':{}}
     156                perm_dirs[file]={u'USER':{},u'GROUP':{},u'user':{},u'group':{},u'other':{},u'mask':{}}
    154157                continue
    155             if line != '':
    156                 field=[ x for x in line.split(' ') if x != '']
    157                 if field[0] in ['other','mask']:
     158            if line != u'':
     159                field=[ x for x in line.split(u' ') if x != u'']
     160                if field[0] in [u'other',u'mask']:
    158161                    perm_dirs[file][field[0]]=field[1]
    159162                else:
     
    162165            for (u,udata) in users:
    163166                #TEST HOME
    164                 if os.path.exists(udata['homeDirectory'][0]):
    165                     output[u] = {'HAS_HOME': True}
    166 
    167                     homedir=udata['homeDirectory'][0]
    168                     user=udata['uid'][0]
     167                if os.path.exists(udata[u'homeDirectory'][0]):
     168                    output[u] = {u'HAS_HOME': True}
     169
     170                    homedir=udata[u'homeDirectory'][0]
     171                    user=udata[u'uid'][0]
    169172
    170173                    try:
    171                         output[u]['PERM_OK']=\
    172                             perm_dirs[homedir]['USER'][user] == 'rwx' \
    173                             and perm_dirs[homedir]['user'][user] == 'rwx' \
    174                             and perm_dirs[homedir]['GROUP']['nogroup'] == 'r-x' \
    175                             and perm_dirs[homedir]['group']['students'] == '---' \
    176                             and perm_dirs[homedir]['group']['teachers'] == 'rwx' \
    177                             and perm_dirs[homedir]['group']['admins'] == 'rwx' \
    178                             and perm_dirs[homedir]['other'] == '---'
     174                        output[u][u'PERM_OK']=\
     175                            perm_dirs[homedir][u'USER'][user] == u'rwx' \
     176                            and perm_dirs[homedir][u'user'][user] == u'rwx' \
     177                            and perm_dirs[homedir][u'GROUP'][u'nogroup'] == u'r-x' \
     178                            and perm_dirs[homedir][u'group'][u'students'] == u'---' \
     179                            and perm_dirs[homedir][u'group'][u'teachers'] == u'rwx' \
     180                            and perm_dirs[homedir][u'group'][u'admins'] == u'rwx' \
     181                            and perm_dirs[homedir][u'other'] == u'---'
    179182                    except:
    180                         output[u]['PERM_OK']=False
     183                        output[u][u'PERM_OK']=False
    181184
    182185                    if u in logged_users:
    183                         output[u]['MOUNTS_OK']=self.check_mounts(u,'student',**kwargs)
    184                     else:
    185                         output[u]['MOUNTS_OK']=(None,['NOT_LOGGED_IN'])
    186                 else:
    187                     output[u]={'HAS_HOME': False}
     186                        output[u][u'MOUNTS_OK']=self.check_mounts(u,u'student',**kwargs)
     187                    else:
     188                        output[u][u'MOUNTS_OK']=(None,[u'NOT_LOGGED_IN'])
     189                else:
     190                    output[u]={u'HAS_HOME': False}
    188191
    189192        # TEACHERS
     
    191194            for (u,udata) in teachers:
    192195                #TEST HOME
    193                 if os.path.exists(udata['homeDirectory'][0]):
    194                     output[u] = {'HAS_HOME': True}
    195 
    196                     homedir=udata['homeDirectory'][0]
    197                     user=udata['uid'][0]
     196                if os.path.exists(udata[u'homeDirectory'][0]):
     197                    output[u] = {u'HAS_HOME': True}
     198
     199                    homedir=udata[u'homeDirectory'][0]
     200                    user=udata[u'uid'][0]
    198201
    199202                    try:
    200                         output[u]['PERM_OK']=\
    201                             perm_dirs[homedir]['USER'][user] == 'rwx' \
    202                             and perm_dirs[homedir]['user'][user] == 'rwx' \
    203                             and perm_dirs[homedir]['GROUP']['nogroup'] == 'r-x' \
    204                             and perm_dirs[homedir]['group']['teachers'] == '---' \
    205                             and perm_dirs[homedir]['group']['admins'] == 'rwx' \
    206                             and perm_dirs[homedir]['other'] == '---'
     203                        output[u][u'PERM_OK']=\
     204                            perm_dirs[homedir][u'USER'][user] == u'rwx' \
     205                            and perm_dirs[homedir][u'user'][user] == u'rwx' \
     206                            and perm_dirs[homedir][u'GROUP'][u'nogroup'] == u'r-x' \
     207                            and perm_dirs[homedir][u'group'][u'teachers'] == u'---' \
     208                            and perm_dirs[homedir][u'group'][u'admins'] == u'rwx' \
     209                            and perm_dirs[homedir][u'other'] == u'---'
    207210                    except:
    208                         output[u]['PERM_OK']=False
     211                        output[u][u'PERM_OK']=False
    209212
    210213                    if u in logged_users:
    211                         output[u]['MOUNTS_OK']=self.check_mounts(u,'teacher',**kwargs)
    212                     else:
    213                         output[u]['MOUNTS_OK']=(None,['NOT_LOGGED_IN'])
    214 
    215                 else:
    216                     output[u]={'HAS_HOME': False}
     214                        output[u][u'MOUNTS_OK']=self.check_mounts(u,u'teacher',**kwargs)
     215                    else:
     216                        output[u][u'MOUNTS_OK']=(None,[u'NOT_LOGGED_IN'])
     217
     218                else:
     219                    output[u]={u'HAS_HOME': False}
    217220
    218221        # ADMINS
     
    220223            for (u,udata) in admins:
    221224                #TEST HOME
    222                 if os.path.exists(udata['homeDirectory'][0]):
    223                     output[u] = {'HAS_HOME': True}
    224 
    225                     homedir=udata['homeDirectory'][0]
    226                     user=udata['uid'][0]
     225                if os.path.exists(udata[u'homeDirectory'][0]):
     226                    output[u] = {u'HAS_HOME': True}
     227
     228                    homedir=udata[u'homeDirectory'][0]
     229                    user=udata[u'uid'][0]
    227230
    228231                    try:
    229                         output[u]['PERM_OK']=\
    230                             perm_dirs[homedir]['USER'][user] == 'rwx' \
    231                             and perm_dirs[homedir]['user'][user] == 'rwx' \
    232                             and perm_dirs[homedir]['GROUP']['nogroup'] == 'r-x' \
    233                             and perm_dirs[homedir]['group']['admins'] == 'rwx' \
    234                             and perm_dirs[homedir]['other'] == '---'
     232                        output[u][u'PERM_OK']=\
     233                            perm_dirs[homedir][u'USER'][user] == u'rwx' \
     234                            and perm_dirs[homedir][u'user'][user] == u'rwx' \
     235                            and perm_dirs[homedir][u'GROUP'][u'nogroup'] == u'r-x' \
     236                            and perm_dirs[homedir][u'group'][u'admins'] == u'rwx' \
     237                            and perm_dirs[homedir][u'other'] == u'---'
    235238                    except:
    236                         output[u]['PERM_OK']=False
     239                        output[u][u'PERM_OK']=False
    237240
    238241                    if u in logged_users:
    239                         output[u]['MOUNTS_OK']=self.check_mounts(u,'admin',**kwargs)
    240                     else:
    241                         output[u]['MOUNTS_OK']=(None,['NOT_LOGGED_IN'])
    242 
    243                 else:
    244                     output[u]={'HAS_HOME': False}
    245 
    246         return {'USERS_INFO':perm_dirs,'USER_TEST':output}
     242                        output[u][u'MOUNTS_OK']=self.check_mounts(u,u'admin',**kwargs)
     243                    else:
     244                        output[u][u'MOUNTS_OK']=(None,[u'NOT_LOGGED_IN'])
     245
     246                else:
     247                    output[u]={u'HAS_HOME': False}
     248
     249        return {u'USERS_INFO':perm_dirs,u'USER_TEST':output}
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxuserstest.py

    r6420 r6450  
    33import hwdetector.utils.log as log
    44
    5 log.debug("File "+__name__+" loaded")
     5log.debug(u'File '+__name__+u' loaded')
    66
    77class LlxUsersTest(Detector):
    8     _NEEDS=['MOUNTS_INFO','USER_TEST']
    9     _PROVIDES=['LLXUSERS_TEST']
     8    _NEEDS=[u'MOUNTS_INFO',u'USER_TEST']
     9    _PROVIDES=[u'LLXUSERS_TEST']
    1010
    1111    def make_result(self,*args,**kwargs):
    12         ret=''
    13         if not ('result' in kwargs and 'msg' in kwargs):
     12        ret=u''
     13        if not (u'result' in kwargs and u'msg' in kwargs):
    1414            return
    15         if isinstance(kwargs['result'],list):
    16             result=kwargs['result']
     15        if isinstance(kwargs[u'result'],list):
     16            result=kwargs[u'result']
    1717        else:
    18             result=[str(kwargs['result'])]
     18            result=[unicode(kwargs[u'result'])]
    1919
    2020        for x in result:
    21             ret+='{}> {}: {}\n'.format(self.__class__.__name__,x,kwargs['msg'])
     21            ret+=u'{}> {}: {}\n'.format(self.__class__.__name__,x,kwargs[u'msg'])
    2222        return ret
    2323
     
    2626        status = False
    2727        msg_debug=[]
    28         mounts_info=kwargs['MOUNTS_INFO']
    29         user_test=kwargs['USER_TEST']
     28        mounts_info=kwargs[u'MOUNTS_INFO']
     29        user_test=kwargs[u'USER_TEST']
    3030        for u in sorted(user_test.iterkeys()):
    3131            status=True
    32             if user_test[u]['HAS_HOME']:
    33                 msg_debug.append('\n{}\n'.format(u.upper()))
     32            if user_test[u][u'HAS_HOME']:
     33                msg_debug.append(u'\n{}\n'.format(u.upper()))
    3434                for k in user_test[u]:
    35                     if k != 'MOUNTS_OK':
    36                         msg_debug.append('{} {}\n'.format(k,user_test[u][k]))
     35                    if k != u'MOUNTS_OK':
     36                        msg_debug.append(u'{} {}\n'.format(k,user_test[u][k]))
    3737                        if user_test[u][k] == False:
    38                             msg_debug.append('Home of user {} has wrong permission,owners or acl\'s\n'.format(u))
    39                             msg.append(self.make_result(result=['Home of user {} has wrong permission,owners or acl\'s'.format(u)],msg='Nok !'))
     38                            msg_debug.append(u'Home of user {} has wrong permission,owners or acl\'s\n'.format(u))
     39                            msg.append(self.make_result(result=[u'Home of user {} has wrong permission,owners or acl\'su'.format(u)],msg='Nok !'))
    4040                            status = False
    4141                    else:
    42                         msg_debug.append('{} {}\nMESSAGES:\n{}\n'.format(k,user_test[u][k][0],'\n'.join(user_test[u][k][1])))
     42                        msg_debug.append(u'{} {}\nMESSAGES:\n{}\n'.format(k,user_test[u][k][0],u'\n'.join(user_test[u][k][1])))
    4343                        if user_test[u][k][0] == False:
    44                             msg.append(self.make_result(result=['User {} has wrong mounts, detection says'.format(u)],msg=''))
    45                             msg.append(self.make_result(result=user_test[u]['MOUNTS_OK'][1],msg=''))
     44                            msg.append(self.make_result(result=[u'User {} has wrong mounts, detection says'.format(u)],msg=u''))
     45                            msg.append(self.make_result(result=user_test[u][u'MOUNTS_OK'][1],msg=u''))
    4646                            status = False
    4747                if status:
    48                     msg.append(self.make_result(result=['Home of user {} seems with good permission,owners and acl\'s'.format(u)],msg='Ok!'))
    49                 if 'NOT_LOGGED_IN' in user_test[u]['MOUNTS_OK'][1]:
    50                     msg.append(self.make_result(result='User {} not logged in, so i can\'t expect to analyze any mounts'.format(u),msg=''))
     48                    msg.append(self.make_result(result=[u'Home of user {} seems with good permission,owners and acl\'su'.format(u)],msg='Ok!'))
     49                if u'NOT_LOGGED_IN' in user_test[u][u'MOUNTS_OK'][1]:
     50                    msg.append(self.make_result(result=u'User {} not logged in, so i can\'t expect to analyze any mountsu'.format(u),msg=''))
    5151                else:
    52                     msg.append(self.make_result(result=['User {} has correct mounts, detection says'.format(u)],msg=''))
    53                     msg.append(self.make_result(result=user_test[u]['MOUNTS_OK'][1],msg='Ok!'))
     52                    msg.append(self.make_result(result=[u'User {} has correct mounts, detection says'.format(u)],msg=u''))
     53                    msg.append(self.make_result(result=user_test[u][u'MOUNTS_OK'][1],msg=u'Ok!'))
    5454
    55         msg=''.join(msg)
    56         msg_debug=''.join(msg_debug)
     55        msg=u''.join(msg)
     56        msg_debug=u''.join(msg_debug)
    5757        log.debug(msg_debug)
    58         return {'LLXUSERS_TEST':{'status':status,'msg':msg}}
     58        return {u'LLXUSERS_TEST':{u'status':status,u'msg':msg}}
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/modules/llxversion.py

    r6399 r6450  
    33import hwdetector.utils.log as log
    44
    5 log.debug("File "+__name__+" loaded")
     5log.debug(u'File '+__name__+u' loaded')
    66
    77class LlxVersion(Detector):
    8     _PROVIDES=["LLIUREX_VERSION","LLIUREX_RELEASE","LLIUREX_SESSION_TYPE","HAS_MIRROR","ARCHITECTURE",'LOGIN_TYPE']
    9     _NEEDS = ['HELPER_EXECUTE']
     8    _PROVIDES=[u'LLIUREX_VERSION',u'LLIUREX_RELEASE',u'LLIUREX_SESSION_TYPE',u'HAS_MIRROR',u'ARCHITECTURE',u'LOGIN_TYPE']
     9    _NEEDS = [u'HELPER_EXECUTE']
    1010    def run(self,*args,**kwargs):
    1111        d={}
    1212        output={}
    13         output.setdefault('LLIUREX_VERSION',None)
    14         output.update({'LLIUREX_VERSION':self.execute(run="lliurex-version -n",stderr=None)})
     13        output.setdefault(u'LLIUREX_VERSION',None)
     14        output.update({u'LLIUREX_VERSION':self.execute(run=u'lliurex-version -n',stderr=None)})
    1515
    1616        try:
    17             for k,v in [ x.split('=') for x in self.execute(run="lliurex-version -a -e",stderr=None).replace('\n',' ').split(' ') ]:
     17            for k,v in [ x.split(u'=') for x in self.execute(run=u'lliurex-version -a -e',stderr=None).replace(u'\n',u' ').split(u' ') ]:
    1818                d[k]=v
    1919        except:
    2020            pass
    2121
    22         output.setdefault('LLIUREX_RELEASE',None)
    23         for x in ['CLIENT','DESKTOP','SERVER','INFANTIL','MUSIC','PIME']:
    24             if x in d and d[x].lower() == 'yes':
    25                 output['LLIUREX_RELEASE']=x
     22        output.setdefault(u'LLIUREX_RELEASE',None)
     23        for x in [u'CLIENT',u'DESKTOP',u'SERVER',u'INFANTIL',u'MUSIC',u'PIME']:
     24            if x in d and d[x].lower() == u'yes':
     25                output[u'LLIUREX_RELEASE']=x
    2626
    27         output.setdefault('LLIUREX_SESSION_TYPE',None)
    28         for x in ['LIVE','SEMI','FAT','THIN']:
    29             if x in d and d[x].lower() == 'yes':
    30                 output['LLIUREX_SESSION_TYPE']=x
     27        output.setdefault(u'LLIUREX_SESSION_TYPE',None)
     28        for x in [u'LIVE',u'SEMI',u'FAT',u'THIN']:
     29            if x in d and d[x].lower() == u'yes':
     30                output[u'LLIUREX_SESSION_TYPE']=x
    3131
    32         if 'MIRROR' in d and d['MIRROR'].lower() == 'true':
    33             output['HAS_MIRROR'] = True
     32        if u'MIRROR' in d and d[u'MIRROR'].lower() == u'true':
     33            output[u'HAS_MIRROR'] = True
    3434        else:
    35             output['HAS_MIRROR'] = False
     35            output[u'HAS_MIRROR'] = False
    3636
    37         output.setdefault('LOGIN_TYPE',None)
    38         if 'LOGIN_TYPE' in d:
    39             output['LOGIN_TYPE']=d['LOGIN_TYPE']
     37        output.setdefault(u'LOGIN_TYPE',None)
     38        if u'LOGIN_TYPE' in d:
     39            output[u'LOGIN_TYPE']=d[u'LOGIN_TYPE']
    4040
    41         output['ARCHITECTURE']=self.execute(run="arch",stderr=None)
     41        output[u'ARCHITECTURE']=self.execute(run=u'arch',stderr=None)
    4242
    4343        return output
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/utils/PluginManager.py

    r6399 r6450  
    55from log import log
    66
    7 #log.debug("File "+__name__+" loaded")
     7#log.debug(u'File '+__name__+u' loaded')
    88
    99def load_module(module_path, filename):
    10     """ returns the module if filename is a module else None """
    11     if filename.endswith('.py'):
     10    u''" returns the module if filename is a module else None u''"
     11    if filename.endswith(u'.py'):
    1212        module = filename[:-3]
    13     elif os.path.exists(os.path.join(module_path, filename, '__init__.py')):
     13    elif os.path.exists(os.path.join(module_path, filename, u'__init__.py')):
    1414        module = filename
    1515    else:
     
    1818        return importlib.import_module(module)
    1919    except:
    20         log.exception('Loading %s failed.' % module)
     20        log.exception(u'Loading %s failed.' % module)
    2121        return None
    2222
     
    3434            if module:
    3535                if module.__name__ in self.modules:
    36                     log.error("Duplicated module found {} unable to continue processing".format(module.__name__))
     36                    log.error(u'Duplicated module found {} unable to continue processing'.format(module.__name__))
    3737                    self.found_duplicates=True
    3838                    continue
     
    4040                self._extract_classes(module,typeobj)
    4141        sys.path.remove(module_path)
    42         log.info("Found {} plugins: {}".format(len(self.found),','.join(self.found)))
     42        log.info(u'Found {} plugins: {}'.format(len(self.found),u','.join(self.found)))
    4343
    4444    def _extract_classes(self, module,typeobj):
     
    4646            obj = getattr(module, name)
    4747            if inspect.isclass(obj):
    48                 #if hasattr(obj, '_VERSION') and obj._VERSION != None and issubclass(obj,typeobj):
     48                #if hasattr(obj, u'_VERSION') and obj._VERSION != None and issubclass(obj,typeobj):
    4949                if issubclass(obj, typeobj) and obj != typeobj:
    50                     #version = getattr(obj, '_VERSION')
    51                     #log.info("Found plugin: %s.%s %s" % (module.__name__, name, version))
     50                    #version = getattr(obj, u'_VERSION')
     51                    #log.info(u'Found plugin: %s.%s %s' % (module.__name__, name, version))
    5252                    if name in self.classes:
    53                         log.error("Duplicated class {} found into module {}, unable to add".format(name,module.__name__))
     53                        log.error(u'Duplicated class {} found into module {}, unable to add'.format(name,module.__name__))
    5454                        self.found_duplicates=True
    5555                        continue
    56                     #self.found.append("{}.{}".format(module.__name__, name))
    57                     self.found.append("{}".format(name))
     56                    #self.found.append(u'{}.{}'.format(module.__name__, name))
     57                    self.found.append(u'{}'.format(name))
    5858                    self.classes[name] = obj
    5959
  • hwdetector/trunk/fuentes/hwdetector.install/hwdetector/utils/log.py

    r6446 r6450  
    1616        self.level = logging.INFO
    1717        self.disabled = False
    18         self.filename_to_log = tempfile.mkstemp()[1] + '.txt'
     18        self.filename_to_log = tempfile.mkstemp()[1] + u'.txt'
    1919        super(logger,self).__init__(*args,**kwargs)
    2020
     
    3030                colorlog.basicConfig(
    3131                    level=self.level,
    32                     #format="[%(asctime)s] %(levelname)s [%(filename)s.%(funcName)s:%(lineno)d] %(message)s",
    33                     format="%(log_color)s[%(asctime)s:%(msecs)d] %(levelname)s [%(filename)s:%(lineno)d] [%(processName)s] %(message)s %(reset)s",
    34                     datefmt="%H:%M] [%S",
     32                    #format=u'[%(asctime)s] %(levelname)s [%(filename)s.%(funcName)s:%(lineno)d] %(message)s',
     33                    format=u'%(log_color)s[%(asctime)s:%(msecs)d] %(levelname)s [%(filename)s:%(lineno)d] [%(processName)s] %(message)s %(reset)s',
     34                    datefmt=u'%H:%M] [%S',
    3535                    stream=sys.stderr
    3636                )
     
    3838                logging.basicConfig(
    3939                    level=self.level,
    40                     #format="[%(asctime)s] %(levelname)s [%(filename)s.%(funcName)s:%(lineno)d] %(message)s",
    41                     format="[%(asctime)s:%(msecs)d] %(levelname)s [%(filename)s:%(lineno)d] [%(processName)s] %(message)s",
    42                     datefmt="%H:%M] [%S",
     40                    #format=u'[%(asctime)s] %(levelname)s [%(filename)s.%(funcName)s:%(lineno)d] %(message)s',
     41                    format=u'[%(asctime)s:%(msecs)d] %(levelname)s [%(filename)s:%(lineno)d] [%(processName)s] %(message)s',
     42                    datefmt=u'%H:%M] [%S',
    4343                    stream=sys.stderr
    4444                )
     
    5050            logging.basicConfig(
    5151                level=self.level,
    52                 #format="[%(asctime)s] %(levelname)s [%(filename)s.%(funcName)s:%(lineno)d] %(message)s",
    53                 format="[%(asctime)s:%(msecs)d] %(levelname)s [%(filename)s:%(lineno)d] [%(processName)s] %(message)s",
    54                 datefmt="%H:%M] [%S",
     52                #format=u'[%(asctime)s] %(levelname)s [%(filename)s.%(funcName)s:%(lineno)d] %(message)s',
     53                format=u'[%(asctime)s:%(msecs)d] %(levelname)s [%(filename)s:%(lineno)d] [%(processName)s] %(message)s',
     54                datefmt=u'%H:%M] [%S',
    5555                stream=sys.stderr
    5656            )
    5757            self.l = logging.getLogger()
    5858
    59         fh=logging.FileHandler(self.filename_to_log,mode='w')
     59        fh=logging.FileHandler(self.filename_to_log,mode=u'w')
    6060        fh.setFormatter(self.l.handlers[0].formatter)
    6161        self.l.addHandler(fh)
     
    8686        self.disabled=False
    8787
    88 log=logger('main')
     88log=logger(u'main')
    8989log.initLog()
    90 #log.debug("File log.py loaded")
     90#log.debug(u'File log.py loaded')
  • hwdetector/trunk/fuentes/setup.py

    r6399 r6450  
    22from setuptools import setup
    33
    4 if __name__ == "__main__":
    5     setup(name='hwdetector',
    6     version='0.1',
    7     description='Simple system detector',
    8     author='Lliurex Team',
    9     author_email='m.angel.juan@gmail.com',
    10     maintainer='M.Angel Juan',
    11     maintainer_email='m.angel.juan@gmail.com',
    12     keywords=['detector'],
    13     url='http://lliurex.net',
    14     license='GPL',
    15     platforms='UNIX',
    16     package_dir={'':'hwdetector.install'},
    17     packages = ['hwdetector','hwdetector/modules','hwdetector/utils'],
     4if __name__ == u'__main__':
     5    setup(name=u'hwdetector',
     6    version=u'0.1',
     7    description=u'Simple system detector',
     8    author=u'Lliurex Team',
     9    author_email=u'm.angel.juan@gmail.com',
     10    maintainer=u'M.Angel Juan',
     11    maintainer_email=u'm.angel.juan@gmail.com',
     12    keywords=[u'detector'],
     13    url=u'http://lliurex.net',
     14    license=u'GPL',
     15    platforms=u'UNIX',
     16    package_dir={u'':u'hwdetector.install'},
     17    packages = [u'hwdetector',u'hwdetector/modulesu',u'hwdetector/utils'],
    1818    include_package_data = True,
    1919    data_files = [],
  • hwdetector/trunk/fuentes/valentin.install/usr/bin/valentin

    r6445 r6450  
    11#!/usr/bin/env python
    22import sys,os
    3 sys.path.insert(0,'/usr/lib/valentin/')
     3sys.path.insert(0,u'/usr/lib/valentin/')
    44import logging
    55import hwdetector.utils.log as log
     
    1717    import threading
    1818    import gi
    19     gi.require_version('Gtk','3.0')
     19    gi.require_version(u'Gtk',u'3.0')
    2020    from gi.repository import Gtk,GObject
    2121    GObject.threads_init()
    2222except Exception as e:
    23     log.error('Unable to import Gtk libraries: {}'.format(e))
     23    log.error(u'Unable to import Gtk libraries: {}'.format(e))
    2424
    2525
    2626def run_in_debug():
    27     gettrace=getattr(sys,'gettrace',None)
     27    gettrace=getattr(sys,u'gettrace',None)
    2828    if gettrace is None:
    2929        return False
     
    4141        if isinstance(var,dict):
    4242            for x in sorted(var.keys()):
    43                 if not (x.lower().startswith('helper') and indent==0):
     43                if not (x.lower().startswith(u'helper') and indent==0):
    4444                    st += u'{}{}\n{}{}'.format(indentation,x,indent_var(var=var[x],indent=indent+1),creturn)
    4545        elif isinstance(var,list) or isinstance(var,tuple):
    46             if len(var) == 2 and var[0] == '__gz__':
    47                 content=zlib.decompress(base64.b64decode(var[1])).decode('utf-8')
    48                 replaced = content.replace(u'\n',indentation+u'\n'+indentation)
     46            if len(var) == 2 and var[0] == u'__gz__':
     47                content=zlib.decompress(base64.b64decode(var[1])).decode(u'utf-8')
     48                replaced = content.replace(u'\nu',indentation+u'\n'+indentation)
    4949                st += u'{}{}'.format(indentation,replaced)
    5050            else:
     
    5656        elif isinstance(var,str):
    5757            try:
    58                 var = var.encode('utf-8')
     58                var = var.encode(u'utf-8')
    5959            except:
    60                 var = var.decode('utf-8')
    61             replaced = var.replace(u'\n',indentation+u'\n'+indentation)
     60                var = var.decode(u'utf-8')
     61            replaced = var.replace(u'\nu',indentation+u'\n'+indentation)
    6262            st += u'{}{}'.format(indentation,replaced)
    6363        elif isinstance(var,unicode):
    64             replaced = var.replace(u'\n',indentation+u'\n'+indentation)
     64            replaced = var.replace(u'\nu',indentation+u'\n'+indentation)
    6565            st += u'{}{}'.format(indentation,replaced)
    6666        elif isinstance(var,bool) or isinstance(var,int) or isinstance(var,float) or var == None:
    6767            st += u'{}{}'.format(indentation,var)
    6868        else:
    69             raise Exception('Unknown type var')
     69            raise Exception(u'Unknown type var')
    7070        return st
    7171    except Exception as e:
     
    7474def make_file(capabilities,*args,**kwargs):
    7575    try:
    76         txt = json.dumps(capabilities,indent=4,separators=(',',':'),sort_keys=True)
     76        txt = json.dumps(capabilities,indent=4,separators=(u',',u':'),sort_keys=True)
    7777        name = tempfile.mkstemp()[1]
    78         with open(name,'w') as f:
    79             f.write(txt.encode('utf-8'))
     78        with open(name,u'w') as f:
     79            f.write(txt.encode(u'utf-8'))
    8080        return name
    8181    except Exception as e:
     
    8484def make_tar(file,*args,**kwargs):
    8585    try:
    86         datestr='{:%Y%m%d%H%M}'.format(datetime.datetime.now())
    87         if kwargs['fname']:
    88             filename = kwargs['fname']
    89         else:
    90             filename = 'valentin-info-{}.tar.gz'.format(datestr)
     86        datestr=u'{:%Y%m%d%H%M}'.format(datetime.datetime.now())
     87        if kwargs[u'fname']:
     88            filename = kwargs[u'fname']
     89        else:
     90            filename = u'valentin-info-{}.tar.gz'.format(datestr)
    9191
    9292        if os.path.exists(file):
    93             with tarfile.open(filename,'w:gz') as f:
    94                 f.add(file,arcname='debug-info-{}.txt'.format(datestr),recursive=False)
     93            with tarfile.open(filename,u'w:gz') as f:
     94                f.add(file,arcname=u'debug-info-{}.txt'.format(datestr),recursive=False)
    9595                logger_message_file=log.filename_to_log
    9696                if os.path.exists(logger_message_file):
    97                     f.add(logger_message_file,arcname=os.path.basename('valentin-debug-log-messages.txt'))
     97                    f.add(logger_message_file,arcname=os.path.basename(u'valentin-debug-log-messages.txt'))
    9898            return filename
    9999    except Exception as e:
     
    109109    #hwd.all_plugins_are_needed=True
    110110    if not run_in_debug():
    111         log.info('USING MAX_RUNNING_TIME !!!')
     111        log.info(u'USING MAX_RUNNING_TIME !!!')
    112112        hwd.MAX_RUNNING_TIME = 30
    113113
    114     #hwd.fake_capabilities={'IAMGOD':'yes'}
     114    #hwd.fake_capabilities={u'IAMGOD':u'yes'}
    115115
    116116    log.debug("Calling run plugins")
    117     #ret = hwd.run(needs=['ALL_TESTS'])
    118     #ret = hwd.run(needs=['LLXSYSTEM_TEST','LLXNETWORK_TEST'])
     117    #ret = hwd.run(needs=[u'ALL_TESTS'])
     118    #ret = hwd.run(needs=[u'LLXSYSTEM_TEST',u'LLXNETWORK_TEST'])
    119119    ret = hwd.run()
    120120
     
    124124
    125125def load_file(*args,**kwargs):
    126     if kwargs.get('fname',None):
    127         filename = kwargs['fname']
     126    if kwargs.get(u'fname',None):
     127        filename = kwargs[u'fname']
    128128    else:
    129129        return False
     
    131131        ftxt=None
    132132        if tarfile.is_tarfile(filename):
    133             with tarfile.open(filename,'r:gz') as tar:
     133            with tarfile.open(filename,u'r:gz') as tar:
    134134                target_file=None
    135135
    136136                for tarinfo in tar.getmembers():
    137                     if 'debug-info' in tarinfo.name.lower():
     137                    if u'debug-info' in tarinfo.name.lower():
    138138                        target_file=tarinfo.name
    139139                        break
     
    142142        else:
    143143            ftxt = None
    144             with open(filename,'r') as f:
     144            with open(filename,u'r') as f:
    145145                ftxt = f.read()
    146146        return ftxt
     
    150150def run_analysis(*args,**kwargs):
    151151
    152     if kwargs.get('capabilities',None):
    153         fileinfo = kwargs.get('capabilities')
    154     if not kwargs.get('ruleset',None):
    155         fileruleset='/usr/share/valentin/valentin.rules'
     152    if kwargs.get(u'capabilities',None):
     153        fileinfo = kwargs.get(u'capabilities')
     154    if not kwargs.get(u'ruleset',None):
     155        fileruleset=u'/usr/share/valentin/valentin.rules'
    156156        if not os.path.exists(fileruleset):
    157157            return False
    158158    else:
    159         fileruleset=kwargs.get('ruleset')[0]
     159        fileruleset=kwargs.get(u'ruleset')[0]
    160160
    161161    rs = ruleset()
     
    175175
    176176    def destroy(self,*args,**kwargs):
    177         log.debug('Exitting gui')
     177        log.debug(u'Exitting gui')
    178178        sys.exit(0)
    179179
     
    181181        model,lpaths=tselection.get_selected_rows()
    182182        id_selected=model[lpaths][0]
    183         if self.gui.coldict[id_selected]['child']:
     183        if self.gui.coldict[id_selected][u'child']:
    184184            tview=tselection.get_tree_view()
    185185            for sel in lpaths:
     
    188188                else:
    189189                    tview.expand_row(sel,False)
    190             self.gui.showText(text=indent_var(var=self.gui.coldict[id_selected]['data']))
     190            self.gui.showText(text=indent_var(var=self.gui.coldict[id_selected][u'data']))
    191191        else:
    192192            self.gui.showText(id_selected)
     
    199199        #self.buffer=Gtk.TextBuffer()
    200200        #self.buffer.set_text(self.text)
    201         self.textview=self.builder.get_object('textview1')
     201        self.textview=self.builder.get_object(u'textview1')
    202202        self.buffer=self.textview.get_buffer()
    203         GObject.idle_add(self.buffer.set_text,'Loading...',priority=GObject.PRIORITY_DEFAULT)
     203        GObject.idle_add(self.buffer.set_text,u'Loading...',priority=GObject.PRIORITY_DEFAULT)
    204204        #self.textview.set_buffer(self.buffer)
    205205        self.id=0
     
    211211        while not self.done:
    212212            time.sleep(0.2)
    213             #self.buffer.set_text('{} {}'.format(self.text,self.id))
     213            #self.buffer.set_text(u'{} {}'.format(self.text,self.id))
    214214            #self.textview.set_buffer(self.buffer)
    215             GObject.idle_add(self.buffer.set_text,'{} {} items'.format('Parsing data ...',self.id),priority=GObject.PRIORITY_DEFAULT)
     215            GObject.idle_add(self.buffer.set_text,u'{} {} items'.format(u'Parsing data ...',self.id),priority=GObject.PRIORITY_DEFAULT)
    216216        #self.buffer.set_text(u'')
    217217        GObject.idle_add(self.buffer.set_text,u'',priority=GObject.PRIORITY_LOW)
     
    225225        if isinstance(data,dict):
    226226            for key in sorted(data.keys()):
    227                 if key.startswith('HELPER'):
     227                if key.startswith(u'HELPER'):
    228228                    continue
    229229                id[0]+=1
    230230                id_child=id[0]
    231                 col=self.store.append(self.coldict[me]['col'],[id_child,key])
    232                 self.coldict[me]['child'].append(id_child)
    233                 self.coldict[id_child]={'parent':me,'col':col,'data':data[key],'me':id_child,'child':[]}
     231                col=self.store.append(self.coldict[me][u'col'],[id_child,key])
     232                self.coldict[me][u'child'].append(id_child)
     233                self.coldict[id_child]={u'parent':me,u'col':col,u'data':data[key],u'me':id_child,u'child':[]}
    234234                self._store_data(data=data[key],id=id)
    235235        elif isinstance(data,list):
    236236            if len(data) > 1:
    237                 if len(data)==2 and data[0] == '__gz__':
    238                     self.coldict[me]['data']=zlib.decompress(base64.b64decode(data[1]))
    239                     self._store_data(data=self.coldict[me]['data'],id=id)
     237                if len(data)==2 and data[0] == u'__gz__':
     238                    self.coldict[me][u'data']=zlib.decompress(base64.b64decode(data[1]))
     239                    self._store_data(data=self.coldict[me][u'data'],id=id)
    240240                else:
    241241                    for x in data:
    242242                        id[0]+=1
    243243                        id_child=id[0]
    244                         col=self.store.append(self.coldict[me]['col'],[id_child,'[{}]'.format(str(data.index(x))).encode('utf-8').decode('utf-8')])
    245                         self.coldict[me]['child'].append(id_child)
    246                         self.coldict[id_child]={'parent':me,'col':col,'data':x,'me':id_child,'child':[]}
     244                        col=self.store.append(self.coldict[me][u'col'],[id_child,u'[{}]'.format(str(data.index(x))).encode(u'utf-8').decode(u'utf-8')])
     245                        self.coldict[me][u'child'].append(id_child)
     246                        self.coldict[id_child]={u'parent':me,u'col':col,u'data':x,u'me':id_child,u'child':[]}
    247247                        self._store_data(data=x,id=id)
    248248            elif len(data) == 1:
    249                 self.coldict[me]['data']=data[0]
     249                self.coldict[me][u'data']=data[0]
    250250                self._store_data(data=data[0],id=id)
    251251        elif isinstance(data,tuple):
     
    254254        elif isinstance(data,str):
    255255            try:
    256                 data=data.encode('utf-8').decode('utf-8')
    257                 self.coldict[me]['data']=data
     256                data=data.encode(u'utf-8').decode(u'utf-8')
     257                self.coldict[me][u'data']=data
    258258            except:
    259259                pass
    260260        elif isinstance(data,unicode):
    261261            try:
    262                 data.decode('utf-8')
     262                data.decode(u'utf-8')
    263263            except:
    264                 data=data.encode('utf-8').decode('utf-8')
    265                 self.coldict[me]['data']=data
    266         else:
    267             self._store_data(data=str(data).encode('utf-8').decode('utf-8'),id=id)
     264                data=data.encode(u'utf-8').decode(u'utf-8')
     265                self.coldict[me][u'data']=data
     266        else:
     267            self._store_data(data=str(data).encode(u'utf-8').decode(u'utf-8'),id=id)
    268268        return True
    269269
    270270    def showData(self,data,*args,**kwargs):
    271         self.treeview=self.builder.get_object('treeview1')
    272         self.store=self.builder.get_object('treestore1')
    273         self.storesort=self.builder.get_object('treemodelsort1')
     271        self.treeview=self.builder.get_object(u'treeview1')
     272        self.store=self.builder.get_object(u'treestore1')
     273        self.storesort=self.builder.get_object(u'treemodelsort1')
    274274        self.storesort.set_sort_column_id(1,Gtk.SortType.ASCENDING)
    275         self.coldict={0:{'parent':0,'col':None,'data':data,'me':0,'child':[]}}
     275        self.coldict={0:{u'parent':0,u'col':None,u'data':data,u'me':0,u'child':[]}}
    276276        self._store_data(data=data)
    277277        self.treeview.set_model(self.storesort)
    278278        self.done=True
    279279
    280     def showText(self,id=0,text='',*args,**kwargs):
    281         if text=='':
     280    def showText(self,id=0,text=u'',*args,**kwargs):
     281        if text==u'':
    282282            if id == 0 or not isinstance(id,int):
    283                 data=''
     283                data=u''
    284284            else:
    285285                coldata=self.coldict[id]
    286                 data=coldata['data']
     286                data=coldata[u'data']
    287287        else:
    288288            data=text
     
    291291            pass
    292292        else:
    293             data=str(data).encode('utf-8').decode('utf-8')
     293            data=str(data).encode(u'utf-8').decode(u'utf-8')
    294294        #self.buffer.set_text(data)
    295295        GObject.idle_add(self.buffer.set_text,data,priority=GObject.PRIORITY_DEFAULT)
     
    300300        if not (self.builder):
    301301            return
    302         self.mainwindow=self.builder.get_object('mainwindow')
     302        self.mainwindow=self.builder.get_object(u'mainwindow')
    303303        self.builder.connect_signals(self.handler)
    304         self.treeview=self.builder.get_object('treeview1')
     304        self.treeview=self.builder.get_object(u'treeview1')
    305305        self.treeview.set_model(Gtk.TreeStore(int,str))
    306306        self.mainwindow.show_all()
     
    309309
    310310    def _load_glade(self,*args,**kwargs):
    311         self.gladefile=kwargs.get('gladefile',None)
    312         log.info('Loading glade file {}'.format(self.gladefile))
     311        self.gladefile=kwargs.get(u'gladefile',None)
     312        log.info(u'Loading glade file {}'.format(self.gladefile))
    313313        if self.gladefile and os.path.exists(self.gladefile):
    314314            try:
    315315                self.builder=Gtk.Builder()
    316316                self.builder.add_from_file(self.gladefile)
    317                 log.info('Loaded gladefile')
     317                log.info(u'Loaded gladefile')
    318318                self._show_window()
    319319            except Exception as e:
    320                 log.error('Can\'t load gladefile')
     320                log.error(u'Can\'t load gladefile')
    321321                self.builder=None
    322322        else:
    323             log.error('can\'t find gladefile')
     323            log.error(u'can\'t find gladefile')
    324324            sys.exit(1)
    325325
    326326
    327327        pass
    328 if __name__ == '__main__':
     328if __name__ == u'__main__':
    329329    try:
    330         parser = argparse.ArgumentParser(description='Simple system diagnostic tool')
    331         dlevels = ['debug','info','warning','error']
    332         parser.add_argument('-d','--debug-level',metavar='debug|info|warning|error',nargs='?',choices=dlevels,help='Set the debug level (default: warning)')
    333         parser.add_argument('-c','--coloured',action='store_const',help='Colorize logger messages',const=True)
    334 
    335         parser.add_argument('-f','--with-file',metavar='filename',nargs='?',help='Filename for results file (default valentin-info-(date).tar.gz')
    336         parser.add_argument('-o','--to-stdout',action='store_const',help='Output results to stdout',const=True)
    337         parser.add_argument('-w','--to-stdout-raw',action='store_const',help='Output results to stdout in json format',const=True)
    338         parser.add_argument('-g','--graphical-mode',action='store_const',help='Show results in graphical mode',const=True)
    339 
    340         parser.add_argument('-a','--analyze-file',metavar='filename',nargs=1,help='Filename to analyze')
    341         parser.add_argument('-x','--run-detection',action='store_const',help='Run detection',const=True)
    342 
    343         parser.add_argument('-s','--suggest',action='store_const',help='Suggest actions to repair system',const=True)
    344         parser.add_argument('-r','--ruleset',metavar='filename',nargs=1,help='Load ruleset when suggest user actions')
     330        parser = argparse.ArgumentParser(description=u'Simple system diagnostic tool')
     331        dlevels = [u'debug',u'info',u'warning',u'error']
     332        parser.add_argument(u'-d',u'--debug-level',metavar=u'debug|info|warning|error',nargs=u'?',choices=dlevels,help=u'Set the debug level (default: warning)')
     333        parser.add_argument(u'-c',u'--coloured',action=u'store_const',help=u'Colorize logger messages',const=True)
     334
     335        parser.add_argument(u'-f',u'--with-file',metavar=u'filename',nargs=u'?',help=u'Filename for results file (default valentin-info-(date).tar.gz')
     336        parser.add_argument(u'-o',u'--to-stdout',action=u'store_const',help=u'Output results to stdout',const=True)
     337        parser.add_argument(u'-w',u'--to-stdout-raw',action=u'store_const',help=u'Output results to stdout in json format',const=True)
     338        parser.add_argument(u'-g',u'--graphical-mode',action=u'store_const',help=u'Show results in graphical mode',const=True)
     339
     340        parser.add_argument(u'-a',u'--analyze-file',metavar=u'filename',nargs=1,help=u'Filename to analyze')
     341        parser.add_argument(u'-x',u'--run-detection',action=u'store_const',help=u'Run detection',const=True)
     342
     343        parser.add_argument(u'-s',u'--suggest',action=u'store_const',help=u'Suggest actions to repair system',const=True)
     344        parser.add_argument(u'-r',u'--ruleset',metavar=u'filename',nargs=1,help=u'Load ruleset when suggest user actions')
    345345        args = parser.parse_args()
    346346
     
    349349            log.disable()
    350350        else:
    351             levels={'debug':logging.DEBUG,'info':logging.INFO,'warning':logging.WARNING,'error':logging.ERROR}
     351            levels={u'debug':logging.DEBUG,u'info':logging.INFO,u'warning':logging.WARNING,u'error':logging.ERROR}
    352352            log.set_level(levels[args.debug_level.lower()])
    353353
     
    360360        if args.with_file:
    361361            fname=args.with_file
    362             if '.' not in fname:
    363                 fname = fname + '.tar.gz'
    364             kw.update({'fname':fname})
     362            if u'.' not in fname:
     363                fname = fname + u'.tar.gz'
     364            kw.update({u'fname':fname})
    365365
    366366        if args.analyze_file:
    367367            fname=args.analyze_file[0]
    368             kw.update({'fname':fname})
     368            kw.update({u'fname':fname})
    369369            capabilities=load_file(**kw)
    370370            if capabilities:
     
    372372                ret = True
    373373                log.info("File {} loaded".format(fname))
    374                 kw.update({'capabilities':capabilities})
     374                kw.update({u'capabilities':capabilities})
    375375            else:
    376376                log.error("File {} can't be loaded".format(fname))
     
    379379            if args.run_detection:
    380380                ret,capabilities=run_detection(**kw)
    381                 log.info('Detection done!')
     381                log.info(u'Detection done!')
    382382                if args.with_file:
    383383                    try:
     
    388388                        log.error("File creation unsuccessful "+str(e))
    389389
    390                 kw.update({'capabilities':capabilities})
     390                kw.update({u'capabilities':capabilities})
    391391            else:
    392                 sys.stderr.write('Missing detection option\n')
     392                sys.stderr.write(u'Missing detection option\n')
    393393                ret = False
    394394
     
    398398                    pr=indent_var(var=capabilities)
    399399                elif args.to_stdout_raw:
    400                     for x in (x for x in capabilities.keys() if x.lower().startswith('helper')):
     400                    for x in (x for x in capabilities.keys() if x.lower().startswith(u'helper')):
    401401                        del capabilities[x]
    402402
     
    404404                        try:
    405405                            if isinstance(var,tuple) or isinstance(var,list):
    406                                 if len(var) == 2 and var[0]=='__gz__':
     406                                if len(var) == 2 and var[0]==u'__gz__':
    407407                                    try:
    408                                         var=zlib.decompress(base64.b64decode(var[1])).decode('utf-8')
     408                                        var=zlib.decompress(base64.b64decode(var[1])).decode(u'utf-8')
    409409                                    except:
    410410                                        pass
     
    422422
    423423                    capabilities=clear_compressed(capabilities)
    424                     pr=json.dumps(capabilities,indent=4,separators=(',',':'),sort_keys=True)
    425 
    426                 sys.stdout.write(pr.encode('utf-8'))
    427                 sys.stderr.write('\n')
     424                    pr=json.dumps(capabilities,indent=4,separators=(u',',u':'),sort_keys=True)
     425
     426                sys.stdout.write(pr.encode(u'utf-8'))
     427                sys.stderr.write(u'\n')
    428428            elif args.graphical_mode:
    429429                GObject.threads_init()
    430                 gui = Gui(gladefile=os.path.dirname(__file__)+'/../lib/valentin/varviewer.glade')
     430                gui = Gui(gladefile=os.path.dirname(__file__)+u'/../lib/valentin/varviewer.glade')
    431431                threading.Thread(target=gui.showData,args=(capabilities,)).start()
    432432                sys.exit(Gtk.main())
  • hwdetector/trunk/fuentes/valentin.install/usr/lib/valentin/ruleset.py

    r6399 r6450  
    33import re
    44
    5 T_COMMENT='#'
    6 T_MULTIPLE='*'
    7 T_CAPTURE='()'
    8 T_FIND='~'
    9 T_REPLACE='{}'
    10 T_SEP=','
    11 T_SPLIT='->'
    12 T_HINT='?'
    13 T_CHILD='.'
    14 T_EQUAL='='
    15 T_NOT_EQUAL='!='
    16 T_LIKE='%'
    17 T_NOT_LIKE='!%'
    18 T_GT='<'
    19 T_LT='>'
    20 T_CONTAIN='%'
    21 T_EXISTENCE='@'
    22 L_STR=['\'','"']
    23 L_EMPTY=['\t',' ']
     5T_COMMENT=u'#'
     6T_MULTIPLE=u'*'
     7T_CAPTURE=u'()'
     8T_FIND=u'~'
     9T_REPLACE=u'{}'
     10T_SEP=u','
     11T_SPLIT=u'->'
     12T_HINT=u'?'
     13T_CHILD=u'.'
     14T_EQUAL=u'='
     15T_NOT_EQUAL=u'!='
     16T_LIKE=u'%'
     17T_NOT_LIKE=u'!%'
     18T_GT=u'<'
     19T_LT=u'>'
     20T_CONTAIN=u'%'
     21T_EXISTENCE=u'@'
     22L_STR=[u'\'',u'"']
     23L_EMPTY=[u'\t',u' ']
    2424
    2525class ruleset:
     
    6363                            break
    6464                        tmp=st.index(s,tmp+1)
    65                         if st[tmp-1]!='\\':
     65                        if st[tmp-1]!=u'\\':
    6666                            double=not double
    6767                            i=tmp
    6868                except Exception as e:
    6969                    if not double:
    70                         #raise Exception('Unbalanced quotes')
     70                        #raise Exception(u'Unbalanced quotes')
    7171                        i=9999
    7272                    idxs.append(i)
     
    109109    def clean_quotes(self,*args,**kwargs):
    110110        v=args[0]
    111         if isinstance(v,str):
    112             return v.strip(''.join(L_STR))
     111        if isinstance(v,str) or isinstance(v,unicode):
     112            return v.strip(u''.join(L_STR))
    113113        elif isinstance(v,dict):
    114114            for v2 in v:
     
    126126            i+=1
    127127            if not done and isinstance(search_on,dict):
    128                 #    raise Exception('Use of key \'{}\x' isn\'t permitted, only dict keys are matched in rules'.format(levelkey))
     128                #    raise Exception(u'Use of key \'{}\xu' isn\'t permitted, only dict keys are matched in rules'.format(levelkey))
    129129                changed_key=None
    130130                for lkey in search_on.keys():
     
    134134
    135135                if T_MULTIPLE in levelkey:
    136                     searched_keys=[x for x in search_on.keys() if levelkey.replace(T_MULTIPLE,'') in x]
     136                    searched_keys=[x for x in search_on.keys() if levelkey.replace(T_MULTIPLE,u'') in x]
    137137                    if searched_keys:
    138138                        for r in searched_keys:
     
    140140                            new_consequences=consequences.replace(T_REPLACE,r).strip()
    141141                            try:
    142                                 self.make_rule('{} -> {} '.format(new_fact,new_consequences))
    143                                 log.debug('Rule repetat: Unrolling to: {} -> {}'.format(new_fact,new_consequences))
     142                                self.make_rule(u'{} -> {} '.format(new_fact,new_consequences))
     143                                log.debug(u'Rule repetat: Unrolling to: {} -> {}'.format(new_fact,new_consequences))
    144144                            except:
    145                                 log.debug('Rule repeat: Cannot unroll to: {} -> {}'.format(new_fact,new_consequences))
     145                                log.debug(u'Rule repeat: Cannot unroll to: {} -> {}'.format(new_fact,new_consequences))
    146146                        return None
    147147                    else:
    148                         raise Exception('Can\'t apply template \'{}\''.format(levelkey))
     148                        raise Exception(u'Can\'t apply template \'{}\''.format(levelkey))
    149149                else:
    150150                    if levelkey not in search_on.keys():
    151                         raise Exception('Use of key \'{}\' not possible'.format(levelkey))
     151                        raise Exception(u'Use of key \'{}\' not possible'.format(levelkey))
    152152                    #fact_key.append(levelkey)
    153153                    search_on=search_on[levelkey]
     
    161161                            search,val=levelkey.split(T_FIND)
    162162                        except:
    163                             raise Exception('Incorrect use for find token')
     163                            raise Exception(u'Incorrect use for find token')
    164164                        lkeys=[key for key in item if search.lower() == key.lower()]
    165165                        if lkeys:
     
    190190
    191191    def make_rule(self,*args,**kwargs):
    192         clean=lambda x: str(x).replace('\\','').strip()
     192        clean=lambda x: str(x).replace(u'\\',u'').strip()
    193193        line=args[0]
    194194        line=line.split(T_SPLIT)
    195         rule={'facts':[],'consequences':[],'hints':[]}
     195        rule={u'facts':[],u'consequences':[],u'hints':[]}
    196196        if len(line) < 2:
    197             raise Exception('No consequences in rule')
     197            raise Exception(u'No consequences in rule')
    198198        if len(line) > 2:
    199             raise Exception('Multiple consequences in rule')
     199            raise Exception(u'Multiple consequences in rule')
    200200        facts=line[0]
    201201        consequences=line[1]
    202         if consequences.strip() == '':
    203             raise Exception('Empty consequences')
    204         if facts.strip() == '':
    205             raise Exception('Empty facts')
     202        if consequences.strip() == u'':
     203            raise Exception(u'Empty consequences')
     204        if facts.strip() == u'':
     205            raise Exception(u'Empty facts')
    206206        fact_list=facts.split(T_SEP)
    207207        for f in fact_list:
     
    217217                except:
    218218                    raise e
    219                 if op == '':
    220                     raise Exception('Missing op')