Changeset 4106


Ignore:
Timestamp:
Apr 5, 2017, 12:01:56 PM (2 years ago)
Author:
Juanma
Message:

Refactorized client

Location:
lliurex-remote-installer/trunk/fuentes
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lliurex-remote-installer/trunk/fuentes/debian/changelog

    r4071 r4106  
     1lliurex-remote-installer (0.3.2) xenial; urgency=medium
     2
     3  * Refactorized client
     4
     5 -- Juanma Navarro Mañez <juanma1980@gmail.com>  Wed, 05 Apr 2017 12:00:31 +0200
     6
    17lliurex-remote-installer (0.3.1) xenial; urgency=high
    28
  • lliurex-remote-installer/trunk/fuentes/lliurex-remote-installer-client.install/usr/share/n4d/python-plugins/LliurexRemoteInstallerClient.py

    r4077 r4106  
    1212        N4D_INSTALLED="LLX_REMOTE_INSTALLER_INSTALLED"
    1313       
    14         #VALOR VARIABLE DEL REPO ADDAPLICATION_SOURCES
     14        #REPO ADDAPLICATION_SOURCES value
    1515        dir_sources="/etc/apt/sources.list.d/"
    1616        file_sources="llxremoteinstaller_sources.list"
    1717        file_sources=str(dir_sources)+str(file_sources)
    1818       
    19         #VALORES DE LOS DICCIONARIOS
     19        #Dict values
    2020        DEB='deb'
    2121        APT='apt'
     
    2424        URL='url'
    2525       
    26         #PAQUETE ESENCIAL PARA LOS PROVIDES
     26        #Essential package for provides
    2727        pack_provide="dctrl-tools"
    2828       
    29         #RESUMEN DE APPS INSTALADAS
     29        #Installed apps
    3030        LIST_APP_FINAL=[]
    3131       
    32        
    33        
    3432        def __init__(self):
     33                self.dbg=1
    3534                pass
    36                
    3735        #def __init__
    38        
     36
     37        def _print_info(self,message):
     38                print("[RemoteInstallerClient] "+str(message))
     39
     40        def _debug(self,message):
     41                if self.dbg==1:
     42                        print("RemoteInstallerClient: "+str(message))
     43                        self._log(message)
     44
     45        def _log(self, message):
     46                logFile="/tmp/remoteInstall.log"
     47                if os.path.exists(logFile):
     48                        f=open (logFile,"a")
     49                else:
     50                        f=open (logFile,"w")
     51                f.write(str(message)+"\n")
     52                f.close()
     53
    3954        def startup(self,options):
    40                
    4155                if os.path.exists(self.file_sources):
    4256                        os.remove(self.file_sources)
     
    4660                                if os.system("host server")==0:
    4761                                        objects["LliureXRemoteInstallerClient"].test_system()
    48                                         #test_system(u,"LliureXRemoteInstallerClient")
    49                 #objects["LliureXRemoteInstallerClient"].test_system()
     62        #def startup
    5063       
    5164        def create_dict (self,mode=[]):
    5265                try:
    53                         #CREACION DEL DICCIONARIO DE LO QUE HEMOS INSTALADO
     66                        #Installed apps dict
    5467                        dict={}
    5568                        for mod in mode:
    5669                                dict[mod]=[]
    57                                                
    5870                        COMMENT="[LLXRemoteInstallerClient] (create_dict) Dictionary is created %s"%(dict)
    59                         print (COMMENT)
     71                        self._debug(COMMENT)
    6072                        return [True,str(COMMENT),dict]
    6173                except Exception as e:
     
    6678        def read_var (self,namevar=None,localhost=None):
    6779                try:
    68                         if localhost in ["",None]:
     80#                       if localhost in ["",None]:
     81                        if not localhost:
    6982                                proxy="https://server:9779"
    7083                        else:
     
    7386                        c=x.ServerProxy(proxy)
    7487                        DICT=c.get_variable("","VariablesManager",namevar)
    75                         COMMENT="[LLXRemoteInstallerClient] (read_var) La variable N4D %s de %s posee el valor %s"%(namevar,proxy,DICT)
    76                        
    77                         print (COMMENT)
     88                        COMMENT="[LLXRemoteInstallerClient] (read_var) Value of N4D var %s of %s is %s"%(namevar,proxy,DICT)
     89                        self._debug(COMMENT)
    7890                        return [True,str(COMMENT),DICT]
    79                        
    80                 except Exception as e:
    81                         return [False,str(e)]
    82                
     91                except Exception as e:
     92                        return [False,str(e)]
    8393        #def_read_list
    8494       
    85        
    8695        def initialize_n4dvar(self,list_dict):
     96                self._debug("FNC: initialize_n4dvar")           
    8797                try:
    8898                        dict={}
    8999                        for x in list_dict:
    90                                 #print "Inicializando...%s"%x
    91100                                dict[x]={}
    92101                                if x == self.APT:
    93                                         print "Es un apt"
     102                                        self._debug("Apt mode")
    94103                                        dict[x]['lliurex']={}
    95104                                        dict[x]['lliurex'][self.LIST]=[]
    96105                                        dict[x]['lliurex'][self.URL]=[]
    97106                                else:
    98                                         #print "Es otra cosa....."
    99107                                        dict[x][self.URL]=[]
    100108                                        dict[x][self.LIST]=[]
    101                         COMMENT=("[LLXRemoteInstallerClient] (initialize_n4dvar) Diccionario inicializado")
    102                         print ("%s" %COMMENT)
     109                        COMMENT=("[LLXRemoteInstallerClient] (initialize_n4dvar) Dict initialized")
     110                        self._debug(COMMENT)
    103111                        return [True,str(COMMENT),dict]
    104                                
    105112                except Exception as e:
    106113                        return [False,str(e)]
    107114       
    108115        #def_initialize_var
    109        
    110        
    111116       
    112117        #def test_var (self,namevar=None,localhost=None,user=None,passwd=None):
    113118        def test_var (self,namevar=None,localhost=None):
    114                 try:
    115                         if localhost in ["",None]:
     119                self._debug("test_var")
     120                try:
     121#                       if localhost in ["",None]:
     122                        if not localhost:
    116123                                proxy="https://server:9779"
    117124                        else:
    118125                                proxy="https://localhost:9779"
    119                                
     126                        self._debug("Proxy: "+proxy)
     127                        self._debug("Localhost: "+str(localhost))
     128                        self._debug("Namevar: "+str(namevar))
    120129                        import xmlrpclib as x
    121130                        c=x.ServerProxy(proxy)
    122                         #u=(user,passwd)
    123131                        VALOR=c.get_variable("","VariablesManager",namevar)
    124                         print "[LLXRemoteInstallerClient] (test_var) El valor de la variable N4D %s del test es:%s"%(namevar,VALOR)
    125                         if  VALOR in [None,'','None']:
    126                                 #print "Dentro.........."
     132                        self._debug("[LLXRemoteInstallerClient] (test_var) Value of N4d var "+str(namevar)+" is: "+str(VALOR))
     133#                       if  VALOR in [None,'','None']:
     134                        if  not VALOR:
    127135                                list_dict=[self.APT,self.DEB,self.SH]
    128                                 #VALOR={}
    129                                 #print list_dict
    130136                                VALOR=self.create_dict ([self.APT,self.DEB,self.SH])[2]
    131                                 #VALOR=self.initialize_n4dvar(list_dict)[2]
    132137                                if objects["VariablesManager"].add_variable(namevar,VALOR,"",namevar,[],False,False)[0]:
    133138                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Added variable %s to VariablesManager with valor %s" %(namevar,VALOR))
    134                                         print ("%s" %COMMENT)
     139                                        self._debug(COMMENT)
    135140                                        return [True,str(COMMENT)]
    136141                                else:
    137                                         COMMENT = ("[LLXRemoteInstallerClient] (test_var) Cannot create it again %s to VariablesManager" %namevar)
    138                                         print ("%s" %COMMENT)
     142                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Cannot create %s again in VariablesManager" %namevar)
     143                                        self._debug(COMMENT)
    139144                                        return [True,str(COMMENT)]
    140145                        else:
    141146                                COMMENT=("[LLXRemoteInstallerClient] (test_var) %s Variable exists in your system, it hasn't been created again" %namevar)
    142                                 print ("%s" %COMMENT)
     147                                self._debug(COMMENT)
    143148                                return [True,str(COMMENT)]
    144149                               
    145150                except Exception as e:
    146                         return [False,str(e)]
    147                        
     151                        self._debug("ERROR test_var" + str(e))
     152                        return [False,str(e)]
    148153        #def_test_var
    149154       
    150        
    151155        def reset_var (self,namevar=None,localhost=None):
    152                 try:
    153                         if localhost in ["",None]:
     156                self._debug("reset_var")
     157                try:
     158#                       if localhost in ["",None]:
     159                        if not localhost:
    154160                                proxy="https://server:9779"
    155161                        else:
     
    160166                        objects["VariablesManager"].set_variable(namevar,data)
    161167                        COMMENT=("[LLXRemoteInstallerClient] (reset_var) %s has been updated" %namevar)
    162                         print ("%s" %COMMENT)
     168                        self._debug(COMMENT)
    163169                        return [True,str(COMMENT)]
    164170                               
     
    168174        #def_reset_var
    169175
    170 
    171 
    172176        def update_var_dict (self,namevar=None,dict={},localhost=None):
     177                self._debug("update_var dict")
    173178                try:
    174179                        if self.test_var(namevar,localhost)[0]:
     
    181186                                objects["VariablesManager"].set_variable(namevar,dict)
    182187                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) %s has been updated with this list of APP %s" %(namevar,dict)
    183                                 print ("%s" %COMMENT)
     188                                self._debug(COMMENT)
    184189                                return [True,str(COMMENT)]
    185190                        else:
    186                                 COMMENT="[LLXRemoteInstallerClient] (update_var_list) Cannot updated variable"
    187                                 print ("%s" %COMMENT)
     191                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) Can't update variable"
     192                                self._debug(COMMENT)
    188193                                return [False,str(COMMENT)]
    189                                
    190194                except Exception as e:
    191195                        return [False,str(e)]
     
    202206                                url_complete=str(url)+str(app)
    203207                                if os.path.exists(file):
    204                                         print "[LLXRemoteInstallerClient] (download) The FILE: %s has been donwloaded before, it will be deleted now."%(file)
     208                                        self._debug("(download) The FILE: "+file+" has been donwloaded before, it will be deleted now.")
    205209                                        os.remove(file)
    206                                 print "[LLXRemoteInstallerClient] (download) The FILE: %s is downloading now to directory %s ....."%(app,file_app)
     210                                self._debug("(download) The FILE: "+app+" is downloading now to directory "+file_app+" .....")
    207211                                urllib.urlretrieve(url_complete,file_app)
    208212                                os.chmod(file_app,0755)
     
    219223                try:
    220224                        if sources_private not in ["",None,[]]:
    221                                 COMMENT="[LLXRemoteInstallerClient](repo_add) REPO IS PARTICULAR %s" %sources_private
    222                                 print ("%s" %COMMENT)
     225                                COMMENT="(repo_add) REPO IS PARTICULAR %s" %sources_private
     226                                self._debug(COMMENT)
    223227                                mode = 'a' if os.path.exists(self.file_sources) else 'w'
    224228                                f_used=open(self.file_sources,mode)
    225                                 print "open(%s,%s)"%(self.file_sources,mode)
     229                                self._debug("open("+self.file_sources+","+mode+")")
    226230                                f_used.write(sources_private+'\n')
    227231                                f_used.close()
    228                                 print "[LLXRemoteInstaller](repo_add) File created now read it"
     232                                self._debug("[LLXRemoteInstaller](repo_add) File created now read it")
    229233                                #NOW READ THE NEW SOURCES.LIST
    230234                                sources=[]
     
    236240                       
    237241                        COMMENT="[LLXRemoteInstallerClient](repo_add) Your repo LLXRemoteInstallerClient has new lines %s"%sources     
    238                         print ("%s" %COMMENT)
     242                        self._debug(COMMENT)
     243
    239244                        return [True,str(COMMENT),sources]
    240        
    241                                
    242245                except Exception as e:
    243246                        return [False,str(e)]
     
    245248        #def_repo_add
    246249       
    247        
    248        
    249250        def repo_restore (self,file=None):
    250                 try:
    251                        
    252                         COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo %s to test APT Aplications is deleted and restore to initial state"%file
    253                         print ("%s" %COMMENT)
     251                self._debug("repo_restore")
     252                try:
     253                       
     254                        COMMENT="(repo_restore) Repo %s to test APT Aplications is deleted and restore to initial state"%file   
     255                        self._debug(COMMENT)
    254256                        if os.path.exists(file):
    255                                 #print "Borrandoooooooooooooooooooooooooooooo"
    256257                                os.remove(file)
    257258                        self.repo_update()
    258                        
    259                         COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo from AddApplications has deleted"       
    260                         print ("%s" %COMMENT)
     259                        #Delete proxy settings
     260                        if os.path.exists("/etc/apt/apt.conf.d/98proxySettings"):
     261                                os.remove("/etc/apt/apt.conf.d/98proxySettings")
     262                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo from AddApplications has been deleted"   
     263                        #self._debug(COMMENT)
    261264                        return [True,str(COMMENT)]
    262265                       
     
    266269        #def_repo_restore
    267270       
    268        
    269271        def repo_update (self):
    270                 try:
    271                         print "[LLXRemoteInstallerClient](repo_restore) Updating indices, please wait........"
     272                self._debug("repo_update")
     273                try:
     274                        self._debug("(repo_restore) Updating indices, please wait........")
    272275                        proc = subprocess.Popen('apt-get update', shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
    273276                        proc.wait()
     
    275278                        self.cache=apt.Cache()
    276279                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Your APT CACHE has updated with new indices"
    277                         print ("%s" %COMMENT)
     280                        #self._debug(COMMENT)
    278281                        return [True,str(COMMENT)]
    279282                       
     
    281284                        return [False,str(e)]
    282285               
    283         #def_repo_restore
    284        
     286        #def_repo_update
     287
     288        def repo_customize_apt(self,repos=[]):
     289                pinFile="/etc/apt/preferences.d/lliurex-pinning"
     290                if os.path.exists(pinFile):
     291                        f=open(pinFile,'a')
     292                        f.write("###\n")
     293                        for repo in repos:
     294                                arrayRepoDir=repo.split(' ')
     295                                repoOrig=arrayRepoDir[1]
     296                                pinLine="Package: *\nPin: origin "+repoOrig+"\nPin-Priority:700\n"
     297                                f.write(pinLine)
     298                        f.close()
     299                #Setup proxy in apt.config.d
     300                prefFile=open("/etc/apt/apt.conf.d/98proxySettings","w")
     301                prefFile.write('Acquire::http::proxy "http://proxy:3128";')
     302                prefFile.close()
     303        #def repo_customize_apt
     304
     305        def repo_restore_config(self):
     306                pinFile="/etc/apt/preferences.d/lliurex-pinning"
     307                if os.path.exists(pinFile):
     308                        f=open(pinFile,'r')
     309                        lines=f.readlines()
     310                        f.close()
     311                        defaultPin=[]
     312                        continueReading=1
     313                        for line in lines:
     314                                if continueReading:
     315                                        if line!="###\n":
     316                                                defaultPin.append(line)
     317                                        else:
     318                                                continueReading=0
     319                                else:
     320                                        break
     321                        f=open(pinFile,'w')
     322                        f.writelines(defaultPin)
     323                        f.close()
     324                if os.path.exists("/etc/apt/apt.conf.d/98proxySettings"):
     325                        os.remove("/etc/apt/apt.conf.d/98proxySettings")
     326                self._debug("Default config restored")
     327        #def repo_restore_config
    285328               
    286         def deb_solvedependence (self,deb=None,list=[]):
     329        def deb_solvedDependency (self,deb=None,list=[]):
    287330                try:
    288331                        for s in list:
     
    290333                                version_deb=s[1]
    291334                                test_deb=s[2]
    292                                 print "[LLXRemoteInstallerClient](deb_solvedependence) DEB: %s has the dependence with * package: %s -- version: %s %s -- "%(deb,name_deb,test_deb,version_deb)
    293                                 #COMPRUEBO SI EXISTE EN MI CACHE, SINO ABORTAMOS EL PROCESO
     335                                self._debug("(deb_solvedDependency) DEB: "+deb+" depends on package: "+name_deb+" -- version: "+test_deb+" "+version_deb+" -- ")
     336                                #Check if exists in cache. If not abort process
    294337                                if name_deb in self.cache:
    295                                         print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence is avaible"
     338                                        #self._debug("[LLXRemoteInstallerClient](deb_solvedDependency) Dependence is avaible")
    296339                                        pkg=self.cache[name_deb]
    297                                         #COMPRUEBO QUE ESTA INSTALADA O PIDO QUE SE INSTALE LA DEPENDENCIA
     340                                        #Check if installed or install dependency
    298341                                        if pkg.is_installed:
    299                                                 print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence IS INSTALLED in your system DO NOTHING WITH IT"
     342                                                self._debug("(deb_solvedDependency) Dependency IS INSTALLED in your system DO NOTHING WITH IT")
    300343                                        else:
    301                                                 print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence %s has to been installed now ......"%(name_deb)
     344                                                self._debug("(deb_solvedDependency) Dependency "+name_deb+" is being installed ......")
    302345                                                list_deb_aux=[]
    303346                                                list_deb_aux.append(name_deb)
    304347                                                self.apt_install(list_deb_aux)
    305348                                else:
    306                                         #ANTES DE ABROTAR EL PROCESO COMPRUEBO QUE NO ES UN PAQUETE VIRTUAL PROCEDENTE DE UN PROVIDES
    307                                         print "[LLXRemoteInstallerClient](deb_solvedependence) Testing if my dependence %s is virtual package"%name_deb
     349                                        #Check if it's a virtual package from a provides
     350                                        self._debug("(deb_solvedDependency) Testing if dependency "+name_deb+" is a virtual package")
    308351                                        result=subprocess.Popen(["LAGUAGE=en_EN; grep-status -FProvides,Package -sPackage,Provides,Status %s"%name_deb],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
    309352                                        virtual_deb=False
    310                                         #REVISAMOS EL RESULTADO A VER SI ES VIRTUAL
    311353                                        for line in result.splitlines():
    312                                                 #print "Test line %s"%line
    313354                                                if "install" in line:
    314                                                         print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence: %s is a virtual package installed in my system"%name_deb
     355                                                        self._debug("(deb_solvedDependency) Dependence: "+name_deb+" is a virtual package installed in my system")
    315356                                                        virtual_deb=True
    316                                         #SOLO DEVOLVEREMOS FALSE SI NO SE CUMPLEN DEPENDENCIAS Y NO ES PAQUETE VIRTUAL
     357                                        #Abort the process only if dependencies doesn't resolv and it's not a virtual package
    317358                                        if not virtual_deb:
    318                                                 COMMENT="[LLXRemoteInstallerClient](deb_solvedependence) Your DEB: %s has dependences without solution with your actual repos to solve this dependence APP: %s can not been installed"%(deb,name_deb)
    319                                                 print COMMENT
     359                                                COMMENT="[LLXRemoteInstallerClient](deb_solvedDependency) Your DEB: %s has unreliable dependencies: %s can not been installed"%(deb,name_deb)
     360                                                #self._debug(COMMENT)
    320361                                                return[False,str(COMMENT)]
    321362                       
    322                         COMMENT="[LLXRemoteInstallerClient](deb_solvedependence) Your DEPENDENCES has been resolved now you can continue to install your DEB: %s"%(deb)
    323                         print COMMENT
     363                        COMMENT="[LLXRemoteInstallerClient](deb_solvedDependency) Your DEPENDENCIES has been resolved. Now will continue installing: %s"%(deb)
     364                        #self._debug(COMMENT)
    324365                        return[True,str(COMMENT)]
    325366                except Exception as e:
     
    329370       
    330371       
    331         def deb_testdependences(self,deb=None,list=[]):
    332                 try:
    333                
    334                         #COMPRUEBO QUE  LAS DEPENDENCIAS ESTAN INSTALADAS
    335                         print "[LLXRemoteInstallerClient](deb_testdependences) Testing your DEB: %s with this dependences list %s"%(deb,list)
    336                         for x in list:
    337                                 print
    338                                 print "[LLXRemoteInstallerClient](deb_testdependences) -------------- Testing this tupla %s ------------------"%x
    339                                 #print len(x)
    340                                 #ME ASEGURO QUE TESTEAMOS UNA DEPENDENCIA DE UN SOLO ELEMENTO, SI ES DE DOS O MAS ES PORQUE ES UN OR SOLO CUMPLIR UNO DE LOS CASOS
     372        def deb_testDependencies(self,deb=None,dependsList=[]):
     373                try:
     374                        #Check if dependencies are installed
     375                        self._debug("(deb_testDependencies) Testing your DEB: "+deb+" against this dependencies list "+str(dependsList))
     376                        for x in dependsList:
     377                                self._debug("[LLXRemoteInstallerClient](deb_testDependencies) -------------- Testing this tupla "+str(x)+" ------------------")
     378                                #If dependency has more than one element is an "OR" dependency. Must resolv one of them
    341379                                if len(x)<2:
    342                                         if self.deb_solvedependence(deb,x)[0] == 'False':
     380                                        if self.deb_solvedDependency(deb,x)[0] == 'False':
    343381                                                name_deb=x[0]
    344                                                 COMMENT="[LLXRemoteInstallerClient](deb_testdependences) Your DEB: %s has dependences without solution with your actual repos, APP: %s can not been installed"%(deb,name_deb)
    345                                                 print COMMENT
     382                                                COMMENT="[LLXRemoteInstallerClient](deb_testDependencies) Your DEB: %s has dependences without solution with your actual repos, APP: %s can not been installed"%(deb,name_deb)
     383                                                #self._debug(COMMENT)
    346384                                                return[False,str(COMMENT)]
    347385                                else:
    348                                         #TENEMOS UNA DEPENDENCIA DE UN OR CON LO QUE UN SOLO TRUE DE UNA DE LAS DEPENDENCIAS PERMITIRA INSTALAR EL DEB
     386                                        #"OR" Dependency, one "True" is enough
    349387                                        OK=False
    350                                         print "[LLXRemoteInstallerClient](deb_testdependences)                    Initializing test for *OR* tupla                     "
     388                                        self._debug("(deb_testDependencies) Initializing test for *OR* tupla")
    351389                                        for s in x:
    352390                                                s=[s]
    353391                                                name_deb=s[0][0]
    354                                                 print "[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, one element is %s"%s
    355                                                 if self.deb_solvedependence(deb,s)[0]:
    356                                                         print "[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, this dependence %s can be install, resolv the conflict"%name_deb
     392                                                if self.deb_solvedDependency(deb,s)[0]:
     393                                                        self._debug("(deb_testDependencies) Testing OR tupla: this dependency "+str(name_deb)+" can be installed, as solves the conflict")
    357394                                                        OK=True
    358395                                                        ok_solved=s
    359                                         if OK in ['False',False]:
    360                                                 COMMENT="[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, can not resolve this OR dependence for %s"%(x)
    361                                                 print COMMENT
     396                                        if not OK:
     397                                                COMMENT="[LLXRemoteInstallerClient](deb_testDependencies) Testing OR tupla: can not resolve this OR dependency for %s"%(x)
     398                                                #self._debug(COMMENT)
    362399                                                return[False,str(COMMENT)]
    363400                                        else:
    364                                                 print "[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, can install this dependence: %s and can resolve OR dependence for %s"%(ok_solved,x)
    365                        
    366                         COMMENT="[LLXRemoteInstallerClient](deb_testdependences) Your DEPENDENCES has been resolved now you can install your DEB: %s"%(deb)
    367                         print COMMENT
     401                                                pass
     402                                                self._debug("(deb_testDependencies) Testing OR tupla, can install this dependency: "+str(ok_solved)+" and can resolve OR dependency for "+str(x))
     403                       
     404                        COMMENT="[LLXRemoteInstallerClient](deb_testDependencies) Dependencies are resolved. Now you can install your DEB: %s"%(deb)
     405                        #self._debug(COMMENT)
    368406                        return[True,str(COMMENT)]
    369                        
    370                 except Exception as e:
    371                         print e
    372                         return [False,str(e)]
    373                
    374         #deb_testdependences
    375        
     407                except Exception as e:
     408                        self._debug("ERROR deb_testDependencies: "+str(e))
     409                        return [False,str(e)]
     410        #deb_testDependencies
    376411       
    377412        def deb_install(self,list_deb=[],dir_deb=None):
     
    379414                        list_ok=[]
    380415                        list_not=[]
    381                         #CARGO LA CACHE DE PAQUETES DEL SISTEMA
    382                         print "[LLXRemoteInstallerClient](deb_install) CACHE has updated with indices"
    383                         #COMPRUEBO CADA DEB QUE TENGO QUE INSTALAR
     416                        #Load apt cache
     417                        self.cache=apt.Cache()
     418                        self._debug("(deb_install) CACHE updated")
     419                        #Check each deb marked to install
    384420                        for deb in list_deb:
    385421                                file_deb=str(dir_deb)+"/"+str(deb)
    386                                 print "[LLXRemoteInstallerClient](deb_install) Test first deb to install: %s in dir: %s"%(deb,file_deb)
     422                                self._debug("(deb_install) Test first deb to install: "+deb+" in dir: "+file_deb)
    387423                                app=apt.debfile.DebPackage(file_deb,self.cache)
    388                                 #COMPRUEBO QUE ES INSTALABLE
     424                                #Check if it's installable
    389425                                if app.check():
    390                                         print "[LLXRemoteInstallerClient](deb_install) The deb can be installed, now test the dependences, please wait...."
    391                                         if self.deb_testdependences(deb,app.depends)[0]:
    392                                                 #CON LAS DEPENDENCIAS COMPROBADAS Y RESUELTAS INSTALAMOS LA APLICACION
    393                                                 print "[LLXRemoteInstallerClient](deb_install) The system are ready to install the DEB: %s"%(deb)
    394                                                 print "[LLXRemoteInstallerClient](deb_install) DEB INSTALLED NOW"
    395                                                 print
     426                                        self._debug("(deb_install) The deb can be installed, now will proceed to check dependencies, please wait....")
     427                                        if self.deb_testDependencies(deb,app.depends)[0]:
     428                                                #Install if all is OK
     429                                                self._debug("(deb_install) The system are ready to install the DEB: "+deb)
    396430                                                app.install()
    397431                                                list_ok.append(deb)
    398432                                        else:
    399                                                 #NO PUEDE RESOLVER LAS DEPENDENCIAS DE ESTE PAQUETE,, NO LO INSTALA
    400                                                 print "[LLXRemoteInstallerClient](deb_install) The system cannot resolve the dependences for your deb, review your repos or DEB if you want to install it: %s"%(deb)
    401                                                 print "[LLXRemoteInstallerClient](deb_install) DEB INSTALLED ABORTED"
    402                                                 print
     433                                                #Failed dependencies
     434                                                self._debug("(deb_install) The system cannot resolve the dependencies for your deb, review your repos or your DEB if you want to install it: "+deb)
    403435                                               
    404436                                else:
    405                                         #EL DEB NO ES INSTALABLE POR ALGUNA RAZON
    406                                         print "[LLXRemoteInstallerClient](deb_install) Your DEB: %s cannot be installed in your system"%(deb)
     437                                        #There's any reason that makes deb uninstallable
     438                                        self._debug("(deb_install) Your DEB: "+deb+" cannot be installed in your system")
    407439                                        list_not.append(deb)
    408                                                                
    409                                        
    410440                               
    411                         COMMENT="The DEBS installed are: %s and DEBS with problems are:%s"%(list_ok, list_not)
     441                        COMMENT="DEBS installed: %s . DEBS with problems:%s"%(list_ok, list_not)
    412442                        return [True,str(COMMENT),list_ok,list_not]
    413443                except Exception as e:
     444                        self._debug("(deb_install) ERROR: "+str(e))
    414445                        return[False,str(e)]
    415                        
    416446        #deb_install
    417447       
     
    421451                        list_not=[]
    422452                        for app in list_sh:
    423                                 print "[LLXRemoteInstallerClient](sh_install) Working with SCRIPT: %s"%app
     453                                self._debug("(sh_install) Working with SCRIPT: "+app)
    424454                                file_app=str(dir)+"/"+app
    425455                                if os.path.exists(file_app):
    426                                         print "[LLXRemoteInstallerClient](sh_install) Executing it, please wait.........."
     456                                        self._debug("(sh_install) Executing it, please wait..........")
    427457                                        proc = subprocess.Popen(file_app, shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
    428458                                        proc.wait()
     
    432462                                        list_ok.append([app,md5])
    433463                                else:
    434                                         print "[LLXRemoteInstallerClient](sh_install) This script not exist in your system."
     464                                        self._debug("(sh_install) The script "+file_app+" not exists in your system.")
    435465                                        list_not.append(app)
    436466                       
    437                         if list_ok not in ["",None,[]]:
    438                                 COMMENT="Your FILES: %s has been executed"%(list_ok)
     467#                       if list_ok not in ["",None,[]]:
     468                        if list_ok:
     469                                COMMENT="Your SCRIPTS: %s had been executed"%(list_ok)
    439470                                return [True,str(COMMENT),list_ok,list_not]
    440471                        else:
    441                                 COMMENT="Some script could not executed in your system, please review it %s"%(list_not)
     472                                COMMENT="Some scripts failed to execute, please check them %s"%(list_not)
    442473                                return [True,str(COMMENT),list_ok,list_not]
    443474                       
     
    448479       
    449480        def apt_install(self,list_apt=[]):
     481                self._debug("App List: "+str(list_apt))
    450482                try:
    451483                        list_apt_ok=[]
    452484                        list_apt_not=[]
    453485                        list_apt_system=[]
    454                         print ""
    455                         print "############################################################"
     486                        self._debug("(apt_install) Apps list: "+str(list_apt))
    456487                        for app in list_apt:
    457                                 print "[LLXRemoteInstallerClient](apt_install) Comprobando si es avaiable e instalable la APP: %s"%app
     488                                self._debug("(apt_install) Checking if app "+app+" is available and installable")
    458489                                if app in self.cache:
    459490                                        pkg=self.cache[app]
    460491                                        if pkg.is_installed:
    461                                                 print "[LLXRemoteInstallerClient](apt_install) The APP: %s is intalled in your system"%(app)
    462                                                 print ""
     492                                                self._debug("(apt_install) The APP: "+app+" is intalled in your system")
    463493                                                list_apt_system.append(app)
    464494                                        else:
    465                                                 print "[LLXRemoteInstallerClient](apt_install) The APP: %s wil be installed soon"%(app)
     495                                                self._debug("(apt_install) The APP: "+app+" wil be installed soon")
    466496                                                pkg.mark_install()
    467497                                                list_apt_ok.append(app)
    468                                                 list_apt_system.append(app)
    469                                                 print ""
     498#                                               list_apt_system.append(app)
    470499                                else:
    471500                                        list_apt_not.append(app)
    472501                                               
    473                         if list_apt_ok not in ["",None,[]]:
    474                                 print "[LLXRemoteInstallerClient](apt_install) Please wait we have to install this APP list: %s"%(list_apt_ok)
    475                                 print "WAIT........"
     502                        if list_apt_ok:
     503                                        #                               self._debug("(apt_install) Please wait while installing: "+str(list_apt_ok))
     504                                self._debug("(apt_install) Please wait while installing: "+str(list_apt_ok))
    476505                                self.cache.commit()
    477                                 if list_apt_not in ["",None,[]]:
    478                                         COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s"%(list_apt_ok)
    479                                 else:
    480                                         COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s but this list cannot installed:%s"%(list_apt_ok, list_apt_not)
    481                         else:
    482                                 #print "[LLXRemoteInstallerClient](apt_install) List to install is empty because your system have the list or do not ha it in your repos"
    483                                 if list_apt_not in ["",None,[]]:
     506#                               if list_apt_not in ["",None,[]]:
     507                                if not list_apt_not:
     508                                        COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s"%(list_apt_system)
     509                                else:
     510                                        COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s but this list cann't be installed:%s"%(list_apt_ok, list_apt_not)
     511                        else:
     512#                               if list_apt_not in ["",None,[]]:
     513                                if not list_apt_not:
    484514                                        COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s"%(list_apt)
    485515                                else:
    486                                         COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s and this list cannot installed because your REPO do not have it:%s"%(list_apt, list_apt_not)
    487                        
    488                         if list_apt_system not in ["",None,[]]:
    489                                 for app in list_apt_system:
    490                                         print "[LLXRemoteInstallerClient](apt_install) The APP: %s is intalled in your system.....Adding to list installed"%(app)
    491                                         list_apt_ok.append(app)
    492                         print COMMENT
    493                         print "%s  ---  %s  ---  %s"%(list_apt_ok,list_apt_not,list_apt_system)
    494                         print "############################################################"
     516                                        COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s and this list cannot be installed because your REPO do not have it:%s"%(list_apt_system, list_apt_not)
     517                       
     518#                       if list_apt_system not in ["",None,[]]:
     519                        if list_apt_ok:
     520                                for app in list_apt_ok:
     521                                        self._debug("[LLXRemoteInstallerClient](apt_install) The APP: "+app+" is intalled in your system.....Adding to installed list")
     522#                                       list_apt_ok.append(app)
     523                        self._debug(COMMENT)
     524                        self._debug(str(list_apt_ok)+"  ---  "+str(list_apt_not)+"  ---  "+str(list_apt_system))
    495525                        return [True,str(COMMENT),list_apt_ok,list_apt_not,list_apt_system]
    496526                               
     
    499529                       
    500530        #apt_install
    501        
    502        
     531
     532        def deb_test(self,appDict,dictOrig):
     533                self._debug("deb_test")
     534                #Get dict values
     535                list_deb=appDict[self.LIST]
     536                url_deb=appDict[self.URL]
     537
     538                #Create download path
     539                dir_deb=str(self.dir_tmp)+"/"+"deb"
     540                #Check if the deb is installed
     541                deb_aux=[]
     542                self._debug("(test_system) Checking if any deb on the list is already installed "+str(list_deb))
     543                for deb in list_deb:
     544                        if deb not in dictOrig:
     545                                self._debug("(test_system)DEB: "+deb+" marked for install")
     546                                deb_aux.append(deb)
     547                        else:
     548                                pass
     549                                self._debug("(test_system)DEB: "+deb+" is already installed")
     550                list_deb=deb_aux
     551                #Download needed debs
     552#               if list_deb not in ["",None,[]]:
     553                if list_deb:
     554                        self._debug("(test_system) Debs list is "+str(list_deb)+" Download path is: "+url_deb)
     555                        self.download(list_deb,url_deb,dir_deb)
     556                        result_deb=self.deb_install(list_deb,dir_deb)
     557                       
     558                else:
     559                        self._debug("(test_system) Deb list is empty")
     560                        result_deb=["","","","",""]
     561                return(result_deb)
     562        #def deb_test
     563
     564        def sh_test(self,appDict,dictOrig):
     565                self._debug("sh_test")
     566                #Get dict values
     567                list_sh=appDict[self.LIST]
     568                url_sh=appDict[self.URL]
     569                #Create donwload path and download needed scripts
     570                dir_sh=str(self.dir_tmp)+"/"+"scripts"
     571                self._debug("Created tmp dir "+dir_sh)
     572#               if list_sh not in ["",None,[]]:
     573                if list_sh:
     574                        sh_aux=[]
     575                        for sh_tupla in list_sh:
     576                                sh=sh_tupla[0]
     577                                md5=sh_tupla[1]
     578                                if sh_tupla not in dictOrig:
     579                                        self._debug("(test_system) SH: must install "+sh)
     580                                        sh_aux.append(sh)
     581                                else:
     582                                        self._debug("(test_system) SH: "+sh+" already installed")
     583                        #Download and execute the scripts
     584                        list_sh=sh_aux 
     585                        self._debug("(test_system) Script list is "+str(list_sh)+" Download to: "+url_sh)
     586                        self.download(list_sh,url_sh,dir_sh)
     587                        if list_sh not in ["",None,[]]:
     588                                result_sh=self.sh_install(list_sh,dir_sh)
     589                        else:
     590                                self._debug("(test_system) Script list is empty")
     591                                result_sh=["","","","",""]
     592                       
     593                else:
     594                        self._debug("(test_system) Script list is empty")
     595                        result_sh=["","","","",""]
     596                return(result_sh)
     597        #def sh_test
     598
     599        def _refine_apt_repoList(self,appDict,dictOrig):
     600                self._debug("_refine_apt_repoList")
     601                repoList=[]
     602                list_apt=[]
     603                for source in appDict:
     604                        self._debug("[LLXRemoteInstallerClient](_refine_apt_repoList) Adding applist from: "+str(source))
     605                        aux_list_apt=appDict[source][self.LIST]
     606                        self._debug("[LLXRemoteInstallerClient](_refine_apt_repoList) Adding PPA: "+str(source))
     607                        url=appDict[source][self.URL]
     608                        apt_aux=[]
     609                        self._debug("(test_system) Checking if apt list is installed "+str(aux_list_apt))
     610                        for apt in aux_list_apt:
     611                                if apt not in dictOrig:
     612                                        self._debug("(test_system) Must install APT: "+apt)
     613                                        apt_aux.append(apt)
     614                                else:
     615                                        self._debug("(test_system) "+apt+" is installed")
     616                        #Add non installed debs to list
     617                        list_apt.extend(apt_aux)
     618                        #configure pinning for new repos
     619                        repoList.append(url)
     620                appsRepoDict={'apt':list_apt,'repos':repoList}
     621                return appsRepoDict
     622        #def _refine_apt_repoList
     623
     624        def apt_test(self,appDict,dict_orig):
     625                self._debug("apt_test")
     626                #Get dict values
     627                list_apt_resume=[]
     628                ubuntu=["deb http://archive.ubuntu.com/ubuntu xenial main restricted universe multiverse","deb http://archive.ubuntu.com/ubuntu xenial-security main restricted universe multiverse","deb http://archive.ubuntu.com/ubuntu xenial-updates main restricted universe multiverse"]
     629                list_apt=[]
     630                result_apt=["","","","",""]
     631                #List with repos for pinning customize
     632                repoList=ubuntu
     633                #Get debs and repos
     634                appsRepoDict=self._refine_apt_repoList(appDict[self.APT],dict_orig[self.APT])
     635                repoList.extend(appsRepoDict['repos'])
     636                list_apt=appsRepoDict['apt']
     637                self.repo_customize_apt(repoList)       
     638                if list_apt:
     639                        for url in repoList:
     640                                if self.repo_add(url):
     641                                        self._debug("(test_system) New REPO has been added to your system")
     642                        if self.repo_update():
     643                                self._debug("[LLXRemoteInstallerClient](test_system) Your CACHE has been updated")
     644                        else:
     645#                               return [False,"failed repo_update"]
     646                                return result_apt
     647                else:
     648#                       return [False,"failed repo_add"]
     649                        return result_apt
     650                        #Proceed with the list, repos are updated
     651                self._debug("[LLXRemoteInstallerClient](test_system) Calling apt_install with "+str(list_apt))
     652                result_apt=self.apt_install(list_apt)[2]
     653                if result_apt:
     654                        for app in result_apt:
     655                                list_apt_resume.append(app)
     656                                #Delete repo if was created by us
     657                        self._debug("Call repo_restore")
     658                        self.repo_restore(self.file_sources)
     659                else:
     660                        self._debug( "[LLXRemoteInstallerClient](test_system) No apps installed")
     661                        result_apt=["","","","",""]
     662
     663                #Restore default config
     664                self._debug("Call repo_restore_config")
     665                self.repo_restore_config()     
     666                result_apt=list_apt_resume
     667                return(result_apt)
     668        #def apt_test
     669
     670        def _update_results(self,dict_orig,result_deb,result_sh,result_apt):
     671                if not dict_orig:
     672                        #Create dict if doesn't exists
     673                        self._debug("[LLXRemoteInstallerClient](test_system) Creando el diccionario.......")
     674                        dict_new=self.create_dict ([self.APT,self.DEB,self.SH])[2]
     675                        dict_new[self.APT]=list(result_apt)
     676                        dict_new[self.DEB]=list(result_deb[2])
     677                        dict_new[self.SH]=list(result_sh[2])
     678                        self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost")
     679                else:
     680                        #Update dict
     681                        dict_new=dict_orig
     682                        log="[LLXRemoteInstallerClient](test_system) Will add APT: %s ** DEBS: %s ** SH: %s "%(result_apt,result_deb[2],result_sh[2])
     683                        self._debug(log)
     684                        #Check the dict against a tuple
     685                        dict_help=self.create_dict ([self.APT,self.DEB,self.SH])[2]
     686                        dict_help[self.APT]=list(result_apt)
     687                        dict_help[self.DEB]=list(result_deb[2])
     688                        dict_help[self.SH]=list(result_sh[2])
     689                        self._debug("[LLXRemoteInstallerClient](test_system) dict to compare is "+str(dict_help))
     690                        #Check values
     691                        for valor_dict in dict_help:
     692                                self._debug("[LLXRemoteInstallerClient](test_system) Test APP from: "+valor_dict)
     693                                try:
     694                                        for app_installed in dict_help[valor_dict]:
     695                                                ok=False
     696                                                self._debug("[LLXRemoteInstallerClient](test_system) Check if app is installed: "+str(app_installed))
     697                                                for app_history in dict_orig[valor_dict]:
     698                                                        log="[LLXRemoteInstallerClient](test_system)  APP Installed: %s -- TESTING -- APP System: %s"%(app_installed,app_history)
     699                                                        self._debug(log)
     700                                                        if app_history == app_installed:
     701                                                                self._debug("[LLXRemoteInstallerClient](test_system) App exists, don't add to dict")
     702                                                                ok=True
     703                                                if not ok:
     704                                                        log="[LLXRemoteInstallerClient](test_system) Adding app to list: %s"%app_installed
     705                                                        self._debug(log)
     706                                                        dict_new[valor_dict].append(app_installed)
     707                                                else:
     708                                                        log="[LLXRemoteInstallerClient](test_system) App hasn't been added to dict: %s"%app_installed
     709                                                        self._debug(log)
     710                                except Exception as e:
     711                                        self._debug("ERROR: "+str(e))
     712                        return (dict_new)
     713        #def _update_results
     714
    503715        def test_system(self):
    504716                try:
    505                         print "*******************************************"
    506                         print "         LLXRemoteInstallerClient                    "
    507                         print "*******************************************"
    508                        
    509                         #OBTENEMOS EL DICCIONARIO DE LAS COSAS INSTALADAS
    510                         #print "[LLXRemoteInstallerClient] (test_system) Test if exists variable local N4D"
     717                       
     718                        #Get installed apps dict
    511719                        self.test_var(self.N4D_INSTALLED,"localhost")
    512                         #print "[LLXRemoteInstallerClient] (test_system) Variablelocal N4D exists, read it"
    513720                        dict_orig=self.read_var(self.N4D_INSTALLED,"localhost")[2]
    514721                                       
    515                         #OBTENEMOS EL DICCIONARIO DE LA VARIABLE DE  N4D DEL SERVER
    516                         dict=self.read_var(self.N4D_VAR)[2]
    517                         #SI EL SERVER NO INDICA QUE INSTALE NADA NO INSTALO NADA
    518                         if dict in ["",None,"None"]:
     722                        #Get server dict
     723                        appDict=self.read_var(self.N4D_VAR)[2]
     724                        #Check the server's dict for install
     725#                       if appDict in ["",None,"None"]:
     726                        if not appDict:
    519727                                COMMENT="[LLXRemoteInstallerClient](test_system) Variable %s do not exist in your server, do nothing"%self.N4D_VAR     
    520                                 print ("%s" %COMMENT)
     728                                self._debug(COMMENT)
    521729                                return [True,str(COMMENT)]
    522730                       
    523                         print ""
    524                         print "*****************************************************************************"
    525                         print ""                       
    526                         print "[LLXRemoteInstallerClient] (test_system) The DICTIONARY to use is: %s"%(dict)
    527                         print ""
    528                         print "[LLXRemoteInstallerClient] (test_system) The DICTIONARY installed in system is: %s"%dict_orig
    529                         print ""
    530                         print "*****************************************************************************"
    531                         print ""
     731                        self._debug("[LLXRemoteInstallerClient] (test_system) The DICTIONARY to use is: "+str(dict))
     732                        self._debug("[LLXRemoteInstallerClient] (test_system) The DICTIONARY installed in your system is: "+str(dict_orig))
    532733                        dict_orig_aux=dict_orig
    533734                       
    534                        
    535                        
    536                        
    537                        
    538                        
    539                        
    540                        
    541                         #TEST DE LOS DEBS                       
    542                         #OBTENEMOS LOS VALORES DEL DICCIONARIO
    543                        
    544                         list_deb=dict[self.DEB][self.LIST]
    545                         url_deb=dict[self.DEB][self.URL]
    546                         #CREAMOS LA RUTA DE DESCARGA
    547                         dir_deb=str(self.dir_tmp)+"/"+"deb"
    548                         #COMPROBAMOS QUE EL DEB NO ESTABA ANTERIORMENTE INSTALADO EN EL SISTEMA
    549                         deb_aux=[]
    550                         print "[LLXRemoteInstallerClient](test_system) Comprobando el listado de DEBS si estaba instalado antes %s"%list_deb
    551                         for deb in list_deb:
    552                                 if deb not in dict_orig[self.DEB]:
    553                                         print "[LLXRemoteInstallerClient](test_system)El DEB:%s no estaba, deberemos de instalarlo"%deb
    554                                         deb_aux.append(deb)
    555                                 else:
    556                                         print "[LLXRemoteInstallerClient](test_system)El DEB:%s esta instalado, NO LO ANYADIMOS"%deb
    557                         list_deb=deb_aux
    558                         #DESCARGAMOS LO NECESARIO SI TENEMOS VALORES
    559                         if list_deb not in ["",None,[]]:
    560                                 print "[LLXRemoteInstallerClient](test_system) El listado de DEBS es %s i lo descargaremos de la URL: %s"%(list_deb,url_deb)
    561                                 self.download(list_deb,url_deb,dir_deb)
    562                                 result_deb=self.deb_install(list_deb,dir_deb)
    563                                
    564                         else:
    565                                 print "[LLXRemoteInstallerClient](test_system) El listado de DEBS esta vacio no es necesario hacer nada"
    566                                 result_deb=["","","","",""]
    567                         print "##########################################################"     
    568                        
    569                        
    570                        
    571                        
    572                        
    573                        
    574                        
    575                        
    576                         #TEST DE LOS SH
    577                         #OBTENEMOS LOS VALORES DEL DICCIONARIO
    578                         list_sh=dict[self.SH][self.LIST]
    579                        
    580                         url_sh=dict[self.SH][self.URL]
    581                        
    582                        
    583                         #CREAMOS LA RUTA DE DESCARGA Y DESCARGAMOS LO NECESARIO SI TENEMOS VALORES
    584                         dir_sh=str(self.dir_tmp)+"/"+"scripts"
    585                         print "3"       
    586                         if list_sh not in ["",None,[]]:
    587                                 sh_aux=[]
    588                                 for sh_tupla in list_sh:
    589                                         sh=sh_tupla[0]
    590                                         md5=sh_tupla[1]
    591                                         if sh_tupla not in dict_orig[self.SH]:
    592                                                 print "[LLXRemoteInstallerClient](test_system)El SH:%s no estaba, deberemos de instalarlo"%sh
    593                                                 sh_aux.append(sh)
    594                                         else:
    595                                                 print "[LLXRemoteInstallerClient](test_system)El SH:%s esta instalado, NO LO ANYADIMOS"%sh
    596                                
    597                                 #UNA VEZ COMPROBADA LA LISTA DE SCRIPTS LOS DESCARGAMOS Y EJECUTAMOS
    598                                 list_sh=sh_aux 
    599                                 print "[LLXRemoteInstallerClient](test_system) El listado de SCRIPTS es %s i lo descargaremos de la URL: %s"%(list_sh,url_sh)
    600                                 self.download(list_sh,url_sh,dir_sh)
    601                                 if list_sh not in ["",None,[]]:
    602                                         result_sh=self.sh_install(list_sh,dir_sh)
    603                                 else:
    604                                         print "[LLXRemoteInstallerClient](test_system) El listado de SCRIPTS esta vacio no es necesario hacer nada"
    605                                         result_sh=["","","","",""]
    606                                
    607                         else:
    608                                 print "[LLXRemoteInstallerClient](test_system) El listado de SCRIPTS esta vacio no es necesario hacer nada"
    609                                 result_sh=["","","","",""]
    610                         print "##########################################################"
    611                        
    612                        
    613                        
    614                        
    615                        
    616                        
    617                        
    618                        
    619                        
    620                         #TEST DE LOS APT
    621                         #OBTENEMOS LOS VALORES DEL DICCIONARIO
    622                        
    623                         list_apt_resume=[]
    624                         ubuntu=["deb http://archive.ubuntu.com/ubuntu xenial main restricted universe multiverse","deb http://archive.ubuntu.com/ubuntu xenial-security main restricted universe multiverse","deb http://archive.ubuntu.com/ubuntu xenial-updates main restricted universe multiverse"]
    625 
    626                         print ""
    627                                
    628                         for x in dict[self.APT]:
    629                                 list_apt=None
    630                                 print "----------------------------------------------------------------"
    631                                 print "[LLXRemoteInstallerClient](test_system) Comprobando el PPA: %s"%x
    632                                 list_apt=dict[self.APT][x][self.LIST]
    633                                 #print "[LLXRemoteInstallerClient](dict_ok) Comprobando el listado de APP: %s"%list_apt
    634                                 url=dict[self.APT][x][self.URL]
    635                                 print "[LLXRemoteInstallerClient](test_system) El listado de APT es %s lo comprobaremos en la URL: %s"%(list_apt,url)
    636                                
    637                                 apt_aux=[]
    638                                 print "[LLXRemoteInstallerClient](test_system) Comprobando el listado de APT si estaba instalado antes %s"%list_apt
    639                                 for apt in list_apt:
    640                                         if apt not in dict_orig[self.APT]:
    641                                                 print "[LLXRemoteInstallerClient](test_system)El APT: %s no estaba, deberemos de instalarlo"%apt
    642                                                 apt_aux.append(apt)
    643                                         else:
    644                                                 print "[LLXRemoteInstallerClient](test_system)El APT: %s esta instalado, NO LO ANYADIMOS"%apt
    645                                 list_apt=apt_aux
    646                                 #print list_apt
    647                                
    648                                 if list_apt not in ["",None,[],]:
    649                                         for line in ubuntu:
    650                                                 self.repo_add(line)
    651                                         if url not in ["",None]:
    652                                                 #COMPROBAMOS SI ES UN REPO NUEVO POR SI HAY QUE CREARLO Y ACTUALIZAR LOS INDICES
    653                                                 #print "entro aqui dos"
    654                                                 if self.repo_add(url)[0]:
    655                                                         print "[LLXRemoteInstallerClient](test_system) New REPO has created in your system"
    656                                                         if self.repo_update()[0]:
    657                                                                 #print "[LLXRemoteInstallerClient](test_system) Your CACHE has updated with new indices"
    658                                                                 pass
    659                                                         else:
    660                                                                 return [False,"false el repo_update"]
    661                                                                 #return [False,self.repo_update()[1]]
    662                                                 else:
    663                                                         #return [False,self.repo_add()[1]]
    664                                                         return [False,"false el repo_add"]
    665                                                
    666                                         #CON LOS REPOS ACTUALIZADOS INSTALAMOS LA LISTA
    667                                         print "[LLXRemoteInstallerClient](test_system) Llamamos a apt_install con la lista %s"%list_apt
    668                                         result_apt=self.apt_install(list_apt)[2]
    669                                         if result_apt not in ["",None,[]]:
    670                                                 for app in result_apt:
    671                                                         list_apt_resume.append(app)
    672                                         #print result_apt[2]
    673                                         #print result_apt[4]
    674                                        
    675                                        
    676                                         #BORRAMOS EL REPO SI FUE CREADO ANTERIORMENTE
    677                                         self.repo_restore(self.file_sources)
    678                                         print ""
    679                                        
    680                                 else:
    681                                         print ""
    682                                         print "[LLXRemoteInstallerClient](test_system) No hacemos nada con este REPO %s esta vacia su lista de APPS"%x
    683                                         result_apt=["","","","",""]
    684                         print ""
    685                         result_apt=list_apt_resume
    686                         print "##########################################################"
    687                        
    688                         #ME ASEGURO  QUE ES UNA LISTA
     735                        #TEST Debs
     736                        self._debug("Call deb_test")
     737                        result_deb=self.deb_test(appDict[self.DEB],dict_orig[self.DEB])
     738                        #TEST SH
     739                        self._debug("Call sh_test")
     740                        result_sh=self.sh_test(appDict[self.SH],dict_orig[self.SH])
     741                        #TEST Apt
     742                        self._debug("Call apt_test")
     743                        result_apt=self.apt_test(appDict,dict_orig)
     744                       
     745                        #Check that it's a list
    689746                        sh_installed=list(result_sh[2])
    690                        
    691                        
    692                        
    693                        
    694                        
    695                         #ANYADIMOS LO QUE HEMOS HECHO AL DICCIONARIO DE N4D PARA GUARDAR EL ESTADO ACTUAL
    696                         if dict_orig in ["",None,{}]:
    697                                 #CREAMOS EL DICCIONARIO PORQUE NO EXISTIA DE ANTES
    698                                 print "[LLXRemoteInstallerClient](test_system) Creando el diccionario......."
    699                                 dict_new=self.create_dict ([self.APT,self.DEB,self.SH])[2]
    700                                 dict_new[self.APT]=list(result_apt)
    701                                 dict_new[self.DEB]=list(result_deb[2])
    702                                 dict_new[self.SH]=list(result_sh[2])
    703                                 self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost")
    704                         else:
    705                                 #VAMOS A ACTUALIZAR EL DICCIONARIO CON LO QUE HEMOS HECHO
    706                                 #LO COPIAMOS PARA TENER UN RESPALDO
    707                                 dict_new=dict_orig
    708                                 print "[LLXRemoteInstallerClient](test_system) El diccionario existia, solo lo actualizamos con estos valores iniciales.......%s"%dict_new
    709                                 print "[LLXRemoteInstallerClient](test_system) Anyadiremos las APTs: %s ** DEBS: %s ** SH: %s "%(result_apt,result_deb[2],result_sh[2])
    710                                 #CREAMOS UNA TUPLA PARA REVISAR EL DICCIONARIO
    711                                 dict_help=self.create_dict ([self.APT,self.DEB,self.SH])[2]
    712                                 dict_help[self.APT]=list(result_apt)
    713                                 dict_help[self.DEB]=list(result_deb[2])
    714                                 dict_help[self.SH]=list(result_sh[2])
    715                                 print "[LLXRemoteInstallerClient](test_system) El diccionario a comparar es %s"%dict_help
    716                                 #REVISAMOS LOS VALORES DEL DICCIONARIO
    717                                 for valor_dict in dict_help:
    718                                         print "[LLXRemoteInstallerClient](test_system) Test de las APP del MODO: %s "%valor_dict
    719                                         for app_installed in dict_help[valor_dict]:
    720                                                 ok=False
    721                                                 print "[LLXRemoteInstallerClient](test_system) Comprobamos si la APP Instalada: %s "%app_installed
    722                                                 for app_history in dict_orig[valor_dict]:
    723                                                         print "[LLXRemoteInstallerClient](test_system)  APP Instalada: %s -- TESTING -- APP Systema: %s"%(app_installed,app_history)
    724                                                         if app_history == app_installed:
    725                                                                 print "[LLXRemoteInstallerClient](test_system) Existia con este nombre, no la anyadimos al diccionario"
    726                                                                 ok=True
    727                                                 if not ok:
    728                                                         print "[LLXRemoteInstallerClient](test_system) Anyadiendo a la lista la APP: %s"%app_installed
    729                                                         print ""
    730                                                         dict_new[valor_dict].append(app_installed)
    731                                                 else:
    732                                                         print "[LLXRemoteInstallerClient](test_system) Tras la revision no se anyade al diccionario la APP: %s"%app_installed
    733                                                         print ""
    734                         print ""
    735                         print "-----------------------------------------------"
    736                         print ""
    737                         print "El diccionario final queda %s"%dict_new
    738                         print ""
    739                         print "-----------------------------------------------"
    740                         print "Actualizandolo......."
     747                        #Add results to N4D dict
     748                        dict_new=self._update_results(dict_orig,result_deb,result_sh,result_apt)
     749#                       if dict_orig in ["",None,{}]:
     750                        log="Dict now is %s"%dict_new
     751                        self._debug(log)
     752                        self._debug("Updating.......")
     753                        #Add installed apps to N4D
    741754                        self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost")
    742                         #ANYADIR A LA VARIABLE N4D LAS COSAS INSTALADAS
    743                         #self.update_var_dict(N4D_INSTALLED,new_dict)
    744                         COMMENT="The system has configured with the APPS: %s * has executed the scripts: %s * Install new DEBS: %s"%(result_apt,sh_installed,result_deb[2])
    745                         print COMMENT
     755                        COMMENT="The system has been configured with the APPS: %s * has executed the scripts: %s * Installed new DEBS: %s"%(result_apt,sh_installed,result_deb[2])
     756                        self._debug(COMMENT)
    746757                        return [True,str(COMMENT),result_apt,result_sh[2],result_deb[2],dict_new]
    747758                except Exception as e:
    748759                        return[False,str(e)]
    749760       
    750 
    751 
    752        
    753        
Note: See TracChangeset for help on using the changeset viewer.