source: lliurex-remote-installer/trunk/fuentes/lliurex-remote-installer-client.install/usr/share/n4d/python-plugins/LliurexRemoteInstallerClient.py @ 3919

Last change on this file since 3919 was 3919, checked in by daduve, 3 years ago

Updating sh qith tuplas for md5sum

File size: 26.6 KB
Line 
1import subprocess
2import os
3import urllib
4import apt
5import apt.debfile
6import types
7
8class LliureXRemoteInstallerClient:
9       
10        dir_tmp="/tmp/.LLXRemoteInstallerClient"
11        N4D_VAR="LLX_REMOTE_INSTALLER"
12        N4D_INSTALLED="LLX_REMOTE_INSTALLER_INSTALLED"
13       
14        #VALOR VARIABLE DEL REPO ADDAPLICATION_SOURCES
15        dir_sources="/etc/apt/sources.list.d/"
16        file_sources="llxremoteinstaller_sources"
17        file_sources=str(dir_sources)+str(file_sources)
18       
19        #VALORES DE LOS DICCIONARIOS
20        DEB='deb'
21        APT='apt'
22        SH='sh'
23        LIST='packages'
24        URL='url'
25       
26        #PAQUETE ESENCIAL PARA LOS PROVIDES
27        pack_provide="dctrl-tools"
28       
29        #RESUMEN DE APPS INSTALADAS
30        LIST_APP_FINAL=[]
31       
32        cache=apt.Cache()
33       
34        def __init__(self):
35                pass
36               
37        #def __init__
38       
39        def create_dict (self,mode=[]):
40                try:
41                        #CREACION DEL DICCIONARIO DE LO QUE HEMOS INSTALADO
42                        dict={}
43                        for mod in mode:
44                                dict[mod]=[]
45                                               
46                        COMMENT="[LLXRemoteInstallerClient] (create_dict) Dictionary is created %s"%(dict)
47                        print (COMMENT)
48                        return [True,str(COMMENT),dict]
49                except Exception as e:
50                        print e
51                        return[False,str(e)]
52        #def_create_dict
53       
54        def read_var (self,namevar=None,localhost=None):
55                try:
56                        if localhost in ["",None]:
57                                proxy="https://server:9779"
58                        else:
59                                proxy="https://localhost:9779"
60                        import xmlrpclib as x
61                        c=x.ServerProxy(proxy)
62                        DICT=c.get_variable("","VariablesManager",namevar)
63                        COMMENT="[LLXRemoteInstallerClient] (read_var) La variable N4D %s de %s posee el valor %s"%(namevar,proxy,DICT)
64                       
65                        print (COMMENT)
66                        return [True,str(COMMENT),DICT]
67                       
68                except Exception as e:
69                        return [False,str(e)]
70               
71        #def_read_list
72       
73       
74        def initialize_n4dvar(self,list_dict):
75                try:
76                        dict={}
77                        for x in list_dict:
78                                #print "Inicializando...%s"%x
79                                dict[x]={}
80                                if x == self.APT:
81                                        print "Es un apt"
82                                        dict[x]['lliurex']={}
83                                        dict[x]['lliurex'][self.LIST]=[]
84                                        dict[x]['lliurex'][self.URL]=[]
85                                else:
86                                        #print "Es otra cosa....."
87                                        dict[x][self.URL]=[]
88                                        dict[x][self.LIST]=[]
89                        COMMENT=("[LLXRemoteInstallerClient] (initialize_n4dvar) Diccionario inicializado")
90                        print ("%s" %COMMENT)
91                        return [True,str(COMMENT),dict]
92                               
93                except Exception as e:
94                        return [False,str(e)]
95       
96        #def_initialize_var
97       
98       
99       
100        def test_var (self,namevar=None,localhost=None,user=None,passwd=None):
101                try:
102                        if localhost in ["",None]:
103                                proxy="https://server:9779"
104                        else:
105                                proxy="https://localhost:9779"
106                               
107                        import xmlrpclib as x
108                        c=x.ServerProxy(proxy)
109                        u=(user,passwd)
110                        VALOR=c.get_variable(u,"VariablesManager",namevar)
111                        print "[LLXRemoteInstallerClient] (test_var) El valor de la variable N4D %s del test es:%s"%(namevar,VALOR)
112                        if  VALOR in [None,'','None']:
113                                #print "Dentro.........."
114                                list_dict=[self.APT,self.DEB,self.SH]
115                                #VALOR={}
116                                #print list_dict
117                                VALOR=self.create_dict ([self.APT,self.DEB,self.SH])[2]
118                                #VALOR=self.initialize_n4dvar(list_dict)[2]
119                                if objects["VariablesManager"].add_variable(namevar,VALOR,"",namevar,[],False,False)[0]:
120                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Added variable %s to VariablesManager with valor %s" %(namevar,VALOR))
121                                        print ("%s" %COMMENT)
122                                        return [True,str(COMMENT)]
123                                else:
124                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Cannot create it again %s to VariablesManager" %namevar)
125                                        print ("%s" %COMMENT)
126                                        return [True,str(COMMENT)]
127                        else:
128                                COMMENT=("[LLXRemoteInstallerClient] (test_var) %s Variable exists in your system, it hasn't been created again" %namevar)
129                                print ("%s" %COMMENT)
130                                return [True,str(COMMENT)]
131                               
132                except Exception as e:
133                        return [False,str(e)]
134                       
135        #def_test_var
136       
137       
138        def reset_var (self,namevar=None,localhost=None):
139                try:
140                        if localhost in ["",None]:
141                                proxy="https://server:9779"
142                        else:
143                                proxy="https://localhost:9779"
144                        import xmlrpclib as x
145                        c=x.ServerProxy(proxy)
146                        data=None
147                        objects["VariablesManager"].set_variable(namevar,data)
148                        COMMENT=("[LLXRemoteInstallerClient] (reset_var) %s has been updated" %namevar)
149                        print ("%s" %COMMENT)
150                        return [True,str(COMMENT)]
151                               
152                except Exception as e:
153                        return [False,str(e)]
154               
155        #def_reset_var
156
157
158
159        def update_var_dict (self,namevar=None,dict={},localhost=None,user=None,passwd=None):
160                try:
161                        if self.test_var(namevar,localhost,user,passwd)[0]:
162                                if localhost in ["",None]:
163                                        proxy="https://server:9779"
164                                else:
165                                        proxy="https://localhost:9779"
166                                import xmlrpclib as x
167                                c=x.ServerProxy(proxy)
168                                objects["VariablesManager"].set_variable(namevar,dict)
169                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) %s has been updated with this list of APP %s" %(namevar,dict)
170                                print ("%s" %COMMENT)
171                                return [True,str(COMMENT)]
172                        else:
173                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) Cannot updated variable"
174                                print ("%s" %COMMENT)
175                                return [False,str(COMMENT)]
176                               
177                except Exception as e:
178                        return [False,str(e)]
179               
180        #def_add_list
181       
182        def download(self, apps=[],url=None,dir=None):
183                try:
184                        #CREATE AUX_SOURCES IF IT'S NECESSARY
185                        if not os.path.exists(dir):
186                                os.makedirs(dir)
187                        for app in apps:
188                                file_app=str(dir)+"/"+app
189                                url_complete=str(url)+str(app)
190                                if os.path.exists(file):
191                                        print "[LLXRemoteInstallerClient] (download) The FILE: %s has been donwloaded before, it will be deleted now."%(file)
192                                        os.remove(file)
193                                print "[LLXRemoteInstallerClient] (download) The FILE: %s is downloading now to directory %s ....."%(app,file_app)
194                                urllib.urlretrieve(url_complete,file_app)
195                                os.chmod(file_app,0755)
196                               
197                        COMMENT="Your FILES: %s has been downloaded in %s"%(apps,dir)
198                        return [True,str(COMMENT)]
199                except Exception as e:
200                        return[False,str(e)]
201       
202        #def_download
203       
204       
205        def repo_add (self,sources_private=None):
206                try:
207                        if sources_private not in ["",None,[]]:
208                                COMMENT="[LLXRemoteInstallerClient](repo_add) REPO IS PARTICULAR %s" %sources_private
209                                print ("%s" %COMMENT)
210                                f_used=open(self.file_sources,'a')
211                                f_used.writelines(sources_private)
212                                f_used.close()
213                                #NOW READ THE NEW SOURCES.LIST
214                                sources=[]
215                                file=open(self.file_sources)
216                                f=file.read().splitlines()
217                                for line in f:
218                                        sources.append(line)
219                                file.close()
220                       
221                        COMMENT="[LLXRemoteInstallerClient](repo_add) Your repo LLXRemoteInstallerClient has new lines %s"%sources     
222                        print ("%s" %COMMENT)
223                        return [True,str(COMMENT),sources]
224       
225                               
226                except Exception as e:
227                        return [False,str(e)]
228               
229        #def_repo_update
230       
231       
232       
233        def repo_restore (self,file=None):
234                try:
235                       
236                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo %s to test APT Aplications is deleted and restore to initial state"%file 
237                        print ("%s" %COMMENT)
238                        if os.path.exists(file):
239                                #print "Borrandoooooooooooooooooooooooooooooo"
240                                os.remove(file)
241                        self.repo_update()
242                       
243                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo from AddApplications has deleted"       
244                        print ("%s" %COMMENT)
245                        return [True,str(COMMENT)]
246                       
247                except Exception as e:
248                        return [False,str(e)]
249               
250        #def_repo_restore
251       
252       
253        def repo_update (self):
254                try:
255                        print "[LLXRemoteInstallerClient](repo_restore) Updating indices, please wait........"
256                        #proc = subprocess.Popen('apt-get update', shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
257                        #proc.wait()
258                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Your APT CACHE has updated with new indices"
259                        print ("%s" %COMMENT)
260                        return [True,str(COMMENT)]
261                       
262                except Exception as e:
263                        return [False,str(e)]
264               
265        #def_repo_restore
266       
267               
268        def deb_solvedependence (self,deb=None,list=[]):
269                try:
270                        for s in list:
271                                name_deb=s[0]
272                                version_deb=s[1]
273                                test_deb=s[2]
274                                print "[LLXRemoteInstallerClient](deb_solvedependence) DEB: %s has the dependence with * package: %s -- version: %s %s -- "%(deb,name_deb,test_deb,version_deb)
275                                #COMPRUEBO SI EXISTE EN MI CACHE, SINO ABORTAMOS EL PROCESO
276                                if name_deb in self.cache:
277                                        print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence is avaible"
278                                        pkg=self.cache[name_deb]
279                                        #COMPRUEBO QUE ESTA INSTALADA O PIDO QUE SE INSTALE LA DEPENDENCIA
280                                        if pkg.is_installed:
281                                                print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence IS INSTALLED in your system DO NOTHING WITH IT"
282                                        else:
283                                                print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence %s has to been installed now ......"%(name_deb)
284                                                list_deb_aux=[]
285                                                list_deb_aux.append(name_deb)
286                                                self.apt_install(list_deb_aux)
287                                else:
288                                        #ANTES DE ABROTAR EL PROCESO COMPRUEBO QUE NO ES UN PAQUETE VIRTUAL PROCEDENTE DE UN PROVIDES
289                                        print "[LLXRemoteInstallerClient](deb_solvedependence) Testing if my dependence %s is virtual package"%name_deb
290                                        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]
291                                        virtual_deb=False
292                                        #REVISAMOS EL RESULTADO A VER SI ES VIRTUAL
293                                        for line in result.splitlines():
294                                                #print "Test line %s"%line
295                                                if "install" in line:
296                                                        print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence: %s is a virtual package installed in my system"%name_deb
297                                                        virtual_deb=True
298                                        #SOLO DEVOLVEREMOS FALSE SI NO SE CUMPLEN DEPENDENCIAS Y NO ES PAQUETE VIRTUAL
299                                        if not virtual_deb:
300                                                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)
301                                                print COMMENT
302                                                return[False,str(COMMENT)]
303                       
304                        COMMENT="[LLXRemoteInstallerClient](deb_solvedependence) Your DEPENDENCES has been resolved now you can continue to install your DEB: %s"%(deb)
305                        print COMMENT
306                        return[True,str(COMMENT)]
307                except Exception as e:
308                        return [False,str(e)]
309               
310        #def_debsolvedependence
311       
312       
313        def deb_testdependences(self,deb=None,list=[]):
314                try:
315               
316                        #COMPRUEBO QUE  LAS DEPENDENCIAS ESTAN INSTALADAS
317                        print "[LLXRemoteInstallerClient](deb_testdependences) Testing your DEB: %s with this dependences list %s"%(deb,list)
318                        for x in list:
319                                print
320                                print "[LLXRemoteInstallerClient](deb_testdependences) -------------- Testing this tupla %s ------------------"%x
321                                #print len(x)
322                                #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
323                                if len(x)<2:
324                                        if self.deb_solvedependence(deb,x)[0] == 'False':
325                                                name_deb=x[0]
326                                                COMMENT="[LLXRemoteInstallerClient](deb_testdependences) Your DEB: %s has dependences without solution with your actual repos, APP: %s can not been installed"%(deb,name_deb)
327                                                print COMMENT
328                                                return[False,str(COMMENT)]
329                                else:
330                                        #TENEMOS UNA DEPENDENCIA DE UN OR CON LO QUE UN SOLO TRUE DE UNA DE LAS DEPENDENCIAS PERMITIRA INSTALAR EL DEB
331                                        OK=False
332                                        print "[LLXRemoteInstallerClient](deb_testdependences)                    Initializing test for *OR* tupla                     "
333                                        for s in x:
334                                                s=[s]
335                                                name_deb=s[0][0]
336                                                print "[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, one element is %s"%s
337                                                if self.deb_solvedependence(deb,s)[0]:
338                                                        print "[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, this dependence %s can be install, resolv the conflict"%name_deb
339                                                        OK=True
340                                                        ok_solved=s
341                                        if OK in ['False',False]:
342                                                COMMENT="[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, can not resolve this OR dependence for %s"%(x)
343                                                print COMMENT
344                                                return[False,str(COMMENT)]
345                                        else:
346                                                print "[LLXRemoteInstallerClient](deb_testdependences) Testing OR tupla, can install this dependence: %s and can resolve OR dependence for %s"%(ok_solved,x)
347                       
348                        COMMENT="[LLXRemoteInstallerClient](deb_testdependences) Your DEPENDENCES has been resolved now you can install your DEB: %s"%(deb)
349                        print COMMENT
350                        return[True,str(COMMENT)]
351                       
352                except Exception as e:
353                        print e
354                        return [False,str(e)]
355               
356        #deb_testdependences
357       
358       
359        def deb_install(self,list_deb=[],dir_deb=None):
360                try:
361                        list_ok=[]
362                        list_not=[]
363                        #CARGO LA CACHE DE PAQUETES DEL SISTEMA
364                        print "[LLXRemoteInstallerClient](deb_install) CACHE has updated with indices"
365                        #COMPRUEBO CADA DEB QUE TENGO QUE INSTALAR
366                        for deb in list_deb:
367                                file_deb=str(dir_deb)+"/"+str(deb)
368                                print "[LLXRemoteInstallerClient](deb_install) Test first deb to install: %s in dir: %s"%(deb,file_deb)
369                                app=apt.debfile.DebPackage(file_deb,self.cache)
370                                #COMPRUEBO QUE ES INSTALABLE
371                                if app.check():
372                                        print "[LLXRemoteInstallerClient](deb_install) The deb can be installed, now test the dependences, please wait...."
373                                        if self.deb_testdependences(deb,app.depends)[0]:
374                                                #CON LAS DEPENDENCIAS COMPROBADAS Y RESUELTAS INSTALAMOS LA APLICACION
375                                                print "[LLXRemoteInstallerClient](deb_install) The system are ready to install the DEB: %s"%(deb)
376                                                print "[LLXRemoteInstallerClient](deb_install) DEB INSTALLED NOW"
377                                                print
378                                                app.install()
379                                                list_ok.append(deb)
380                                        else:
381                                                #NO PUEDE RESOLVER LAS DEPENDENCIAS DE ESTE PAQUETE,, NO LO INSTALA
382                                                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)
383                                                print "[LLXRemoteInstallerClient](deb_install) DEB INSTALLED ABORTED"
384                                                print
385                                               
386                                else:
387                                        #EL DEB NO ES INSTALABLE POR ALGUNA RAZON
388                                        print "[LLXRemoteInstallerClient](deb_install) Your DEB: %s cannot be installed in your system"%(deb)
389                                        list_not.append(deb)
390                                                               
391                                       
392                               
393                        COMMENT="The DEBS installed are: %s and DEBS with problems are:%s"%(list_ok, list_not)
394                        return [True,str(COMMENT),list_ok,list_not]
395                except Exception as e:
396                        return[False,str(e)]
397                       
398        #deb_install
399       
400        def sh_install(self,list_sh=[],dir=""):
401                try:
402                        list_ok=[]
403                        list_not=[]
404                        for app in list_sh:
405                                print "[LLXRemoteInstallerClient](sh_install) Working with SCRIPT: %s"%app
406                                file_app=str(dir)+"/"+app
407                                if os.path.exists(file_app):
408                                        print "[LLXRemoteInstallerClient](sh_install) Executing it, please wait.........."
409                                        proc = subprocess.Popen(file_app, shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
410                                        proc.wait()
411                                        lines=subprocess.Popen(["LAGUAGE=en_EN; md5sum %s | awk '{print $1}'"%file_app],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
412                                        for line in lines.splitlines():
413                                                md5=line
414                                        list_ok.append([app,md5])
415                                else:
416                                        print "[LLXRemoteInstallerClient](sh_install) This script not exist in your system."
417                                        list_not.append(app)
418                       
419                        if list_ok not in ["",None,[]]:
420                                COMMENT="Your FILES: %s has been executed"%(list_ok)
421                                return [True,str(COMMENT),list_ok,list_not]
422                        else:
423                                COMMENT="Some script could not executed in your system, please review it %s"%(list_not)
424                                return [True,str(COMMENT),list_ok,list_not]
425                       
426                except Exception as e:
427                        return[False,str(e)]
428                       
429        #sh_install
430       
431        def apt_install(self,list_apt=[]):
432                try:
433                        list_apt_ok=[]
434                        list_apt_not=[]
435                        list_apt_system=[]
436                        print ""
437                        print "############################################################"
438                        for app in list_apt:
439                                print "[LLXRemoteInstallerClient](apt_install) Comprobando si es avaiable e instalable la APP: %s"%app
440                                if app in self.cache:
441                                        pkg=self.cache[app]
442                                        if pkg.is_installed:
443                                                print "[LLXRemoteInstallerClient](apt_install) The APP: %s is intalled in your system"%(app)
444                                                print ""
445                                                list_apt_system.append(app)
446                                        else:
447                                                print "[LLXRemoteInstallerClient](apt_install) The APP: %s wil be installed soon"%(app)
448                                                pkg.mark_install()
449                                                list_apt_ok.append(app)
450                                                list_apt_system.append(app)
451                                                print ""
452                                else:
453                                        list_apt_not.append(app)
454                                               
455                        if list_apt_ok not in ["",None,[]]:
456                                print "[LLXRemoteInstallerClient](apt_install) Please wait we have to install this APP list: %s"%(list_apt_ok)
457                                print "WAIT........"
458                                self.cache.commit()
459                                if list_apt_not in ["",None,[]]:
460                                        COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s"%(list_apt_ok)
461                                else:
462                                        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)
463                        else:
464                                #print "[LLXRemoteInstallerClient](apt_install) List to install is empty because your system have the list or do not ha it in your repos"
465                                if list_apt_not in ["",None,[]]:
466                                        COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s"%(list_apt)
467                                else:
468                                        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)
469                       
470                        if list_apt_system not in ["",None,[]]:
471                                for app in list_apt_system:
472                                        print "[LLXRemoteInstallerClient](apt_install) The APP: %s is intalled in your system.....Adding to list installed"%(app)
473                                        list_apt_ok.append(app)
474                        print COMMENT
475                        print "%s  ---  %s  ---  %s"%(list_apt_ok,list_apt_not,list_apt_system)
476                        print "############################################################"
477                        return [True,str(COMMENT),list_apt_ok,list_apt_not,list_apt_system]
478                               
479                except Exception as e:
480                        return[False,str(e)]
481                       
482        #apt_install
483       
484       
485        def test_system(self,user,passwd):
486                try:
487                        print "*******************************************"
488                        print "         LLXRemoteInstallerClient                    "
489                        print "*******************************************"
490                       
491                        #OBTENEMOS EL DICCIONARIO DE LAS COSAS INSTALADAS
492                        #print "[LLXRemoteInstallerClient] (test_system) Test if exists variable local N4D"
493                        self.test_var(self.N4D_INSTALLED,"localhost",user,passwd)
494                        #print "[LLXRemoteInstallerClient] (test_system) Variablelocal N4D exists, read it"
495                        dict_orig=self.read_var(self.N4D_INSTALLED,"localhost")[2]
496                                       
497                        #OBTENEMOS EL DICCIONARIO DE LA VARIABLE DE  N4D DEL SERVER
498                        dict=self.read_var(self.N4D_VAR)[2]
499                        #SI EL SERVER NO INDICA QUE INSTALE NADA NO INSTALO NADA
500                        if dict in ["",None,"None"]:
501                                COMMENT="[LLXRemoteInstallerClient](test_system) Variable %s do not exist in your server, do nothing"%self.N4D_VAR     
502                                print ("%s" %COMMENT)
503                                return [True,str(COMMENT)]
504                       
505                        print ""
506                        print "*****************************************************************************"
507                        print ""                       
508                        print "[LLXRemoteInstallerClient] (test_system) The DICTIONARY to use is: %s"%(dict)
509                        print ""
510                        print "[LLXRemoteInstallerClient] (test_system) The DICTIONARY installed in system is: %s"%dict_orig
511                        print ""
512                        print "*****************************************************************************"
513                        print ""
514                        dict_orig_aux=dict_orig
515                       
516                       
517                       
518                       
519                       
520                       
521                       
522                       
523                        #TEST DE LOS DEBS                       
524                        #OBTENEMOS LOS VALORES DEL DICCIONARIO
525                       
526                        list_deb=dict[self.DEB][self.LIST]
527                        url_deb=dict[self.DEB][self.URL]
528                        #CREAMOS LA RUTA DE DESCARGA
529                        dir_deb=str(self.dir_tmp)+"/"+"deb"
530                        #COMPROBAMOS QUE EL DEB NO ESTABA ANTERIORMENTE INSTALADO EN EL SISTEMA
531                        deb_aux=[]
532                        print "[LLXRemoteInstallerClient](test_system) Comprobando el listado de DEBS si estaba instalado antes %s"%list_deb
533                        for deb in list_deb:
534                                if deb not in dict_orig[self.DEB]:
535                                        print "[LLXRemoteInstallerClient](test_system)El DEB:%s no estaba, deberemos de instalarlo"%deb
536                                        deb_aux.append(deb)
537                                else:
538                                        print "[LLXRemoteInstallerClient](test_system)El DEB:%s esta instalado, NO LO ANYADIMOS"%deb
539                        list_deb=deb_aux
540                        #DESCARGAMOS LO NECESARIO SI TENEMOS VALORES
541                        if list_deb not in ["",None,[]]:
542                                print "[LLXRemoteInstallerClient](test_system) El listado de DEBS es %s i lo descargaremos de la URL: %s"%(list_deb,url_deb)
543                                self.download(list_deb,url_deb,dir_deb)
544                                result_deb=self.deb_install(list_deb,dir_deb)
545                               
546                        else:
547                                print "[LLXRemoteInstallerClient](test_system) El listado de DEBS esta vacio no es necesario hacer nada"
548                                result_deb=["","","","",""]
549                        print "##########################################################"     
550                       
551                       
552                       
553                       
554                       
555                       
556                       
557                       
558                        #TEST DE LOS SH
559                        #OBTENEMOS LOS VALORES DEL DICCIONARIO
560                        list_sh=dict[self.SH][self.LIST]
561                       
562                        url_sh=dict[self.SH][self.URL]
563                       
564                       
565                        #CREAMOS LA RUTA DE DESCARGA Y DESCARGAMOS LO NECESARIO SI TENEMOS VALORES
566                        dir_sh=str(self.dir_tmp)+"/"+"scripts"
567                        print "3"       
568                        if list_sh not in ["",None,[]]:
569                                sh_aux=[]
570                                for sh_tupla in list_sh:
571                                        sh=sh_tupla[0]
572                                        md5=sh_tupla[1]
573                                        if sh_tupla not in dict_orig[self.SH]:
574                                                print "[LLXRemoteInstallerClient](test_system)El SH:%s no estaba, deberemos de instalarlo"%sh
575                                                sh_aux.append(sh)
576                                        else:
577                                                print "[LLXRemoteInstallerClient](test_system)El SH:%s esta instalado, NO LO ANYADIMOS"%sh
578                               
579                                #UNA VEZ COMPROBADA LA LISTA DE SCRIPTS LOS DESCARGAMOS Y EJECUTAMOS
580                                list_sh=sh_aux 
581                                print "[LLXRemoteInstallerClient](test_system) El listado de SCRIPTS es %s i lo descargaremos de la URL: %s"%(list_sh,url_sh)
582                                self.download(list_sh,url_sh,dir_sh)
583                                if list_sh not in ["",None,[]]:
584                                        result_sh=self.sh_install(list_sh,dir_sh)
585                                else:
586                                        print "[LLXRemoteInstallerClient](test_system) El listado de SCRIPTS esta vacio no es necesario hacer nada"
587                                        result_sh=["","","","",""]
588                               
589                        else:
590                                print "[LLXRemoteInstallerClient](test_system) El listado de SCRIPTS esta vacio no es necesario hacer nada"
591                                result_sh=["","","","",""]
592                        print "##########################################################"
593                       
594                       
595                       
596                       
597                       
598                       
599                       
600                       
601                       
602                        #TEST DE LOS APT
603                        #OBTENEMOS LOS VALORES DEL DICCIONARIO
604                       
605                        list_apt_resume=[]
606                        print ""
607                               
608                        for x in dict[self.APT]:
609                                list_apt=None
610                                print "----------------------------------------------------------------"
611                                print "[LLXRemoteInstallerClient](test_system) Comprobando el PPA: %s"%x
612                                list_apt=dict[self.APT][x][self.LIST]
613                                #print "[LLXRemoteInstallerClient](dict_ok) Comprobando el listado de APP: %s"%list_apt
614                                url=dict[self.APT][x][self.URL]
615                                print "[LLXRemoteInstallerClient](test_system) El listado de APT es %s lo comprobaremos en la URL: %s"%(list_apt,url)
616                               
617                                apt_aux=[]
618                                print "[LLXRemoteInstallerClient](test_system) Comprobando el listado de APT si estaba instalado antes %s"%list_apt
619                                for apt in list_apt:
620                                        if apt not in dict_orig[self.APT]:
621                                                print "[LLXRemoteInstallerClient](test_system)El APT: %s no estaba, deberemos de instalarlo"%apt
622                                                apt_aux.append(apt)
623                                        else:
624                                                print "[LLXRemoteInstallerClient](test_system)El APT: %s esta instalado, NO LO ANYADIMOS"%apt
625                                list_apt=apt_aux
626                                #print list_apt
627                               
628                                if list_apt not in ["",None,[],]:
629                                        if url not in ["",None]:
630                                                #COMPROBAMOS SI ES UN REPO NUEVO POR SI HAY QUE CREARLO Y ACTUALIZAR LOS INDICES
631                                                #print "entro aqui dos"
632                                                if self.repo_add(url)[0]:
633                                                        print "[LLXRemoteInstallerClient](test_system) New REPO has created in your system"
634                                                        if self.repo_update()[0]:
635                                                                #print "[LLXRemoteInstallerClient](test_system) Your CACHE has updated with new indices"
636                                                                pass
637                                                        else:
638                                                                return [False,"false el repo_update"]
639                                                                #return [False,self.repo_update()[1]]
640                                                else:
641                                                        #return [False,self.repo_add()[1]]
642                                                        return [False,"false el repo_add"]
643                                               
644                                        #CON LOS REPOS ACTUALIZADOS INSTALAMOS LA LISTA
645                                        print "[LLXRemoteInstallerClient](test_system) Llamamos a apt_install con la lista %s"%list_apt
646                                        result_apt=self.apt_install(list_apt)[2]
647                                        if result_apt not in ["",None,[]]:
648                                                for app in result_apt:
649                                                        list_apt_resume.append(app)
650                                        #print result_apt[2]
651                                        #print result_apt[4]
652                                       
653                                       
654                                        #BORRAMOS EL REPO SI FUE CREADO ANTERIORMENTE
655                                        self.repo_restore(self.file_sources)
656                                        print ""
657                                       
658                                else:
659                                        print ""
660                                        print "[LLXRemoteInstallerClient](test_system) No hacemos nada con este REPO %s esta vacia su lista de APPS"%x
661                                        result_apt=["","","","",""]
662                        print ""
663                        result_apt=list_apt_resume
664                        print "##########################################################"
665                       
666                        #ME ASEGURO  QUE ES UNA LISTA
667                        sh_installed=list(result_sh[2])
668                       
669                       
670                       
671                       
672                       
673                        #ANYADIMOS LO QUE HEMOS HECHO AL DICCIONARIO DE N4D PARA GUARDAR EL ESTADO ACTUAL
674                        if dict_orig in ["",None,{}]:
675                                #CREAMOS EL DICCIONARIO PORQUE NO EXISTIA DE ANTES
676                                print "[LLXRemoteInstallerClient](test_system) Creando el diccionario......."
677                                dict_new=self.create_dict ([self.APT,self.DEB,self.SH])[2]
678                                dict_new[self.APT]=list(result_apt)
679                                dict_new[self.DEB]=list(result_deb[2])
680                                dict_new[self.SH]=list(result_sh[2])
681                                self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost",user,passwd)
682                        else:
683                                #VAMOS A ACTUALIZAR EL DICCIONARIO CON LO QUE HEMOS HECHO
684                                #LO COPIAMOS PARA TENER UN RESPALDO
685                                dict_new=dict_orig
686                                print "[LLXRemoteInstallerClient](test_system) El diccionario existia, solo lo actualizamos con estos valores iniciales.......%s"%dict_new
687                                print "[LLXRemoteInstallerClient](test_system) Anyadiremos las APTs: %s ** DEBS: %s ** SH: %s "%(result_apt,result_deb[2],result_sh[2])
688                                #CREAMOS UNA TUPLA PARA REVISAR EL DICCIONARIO
689                                dict_help=self.create_dict ([self.APT,self.DEB,self.SH])[2]
690                                dict_help[self.APT]=list(result_apt)
691                                dict_help[self.DEB]=list(result_deb[2])
692                                dict_help[self.SH]=list(result_sh[2])
693                                print "[LLXRemoteInstallerClient](test_system) El diccionario a comparar es %s"%dict_help
694                                #REVISAMOS LOS VALORES DEL DICCIONARIO
695                                for valor_dict in dict_help:
696                                        print "[LLXRemoteInstallerClient](test_system) Test de las APP del MODO: %s "%valor_dict
697                                        for app_installed in dict_help[valor_dict]:
698                                                ok=False
699                                                print "[LLXRemoteInstallerClient](test_system) Comprobamos si la APP Instalada: %s "%app_installed
700                                                for app_history in dict_orig[valor_dict]:
701                                                        print "[LLXRemoteInstallerClient](test_system)  APP Instalada: %s -- TESTING -- APP Systema: %s"%(app_installed,app_history)
702                                                        if app_history == app_installed:
703                                                                print "[LLXRemoteInstallerClient](test_system) Existia con este nombre, no la anyadimos al diccionario"
704                                                                ok=True
705                                                if not ok:
706                                                        print "[LLXRemoteInstallerClient](test_system) Anyadiendo a la lista la APP: %s"%app_installed
707                                                        print ""
708                                                        dict_new[valor_dict].append(app_installed)
709                                                else:
710                                                        print "[LLXRemoteInstallerClient](test_system) Tras la revision no se anyade al diccionario la APP: %s"%app_installed
711                                                        print ""
712                        print ""
713                        print "-----------------------------------------------" 
714                        print ""
715                        print "El diccionario final queda %s"%dict_new
716                        print ""
717                        print "-----------------------------------------------" 
718                        print "Actualizandolo......."
719                        self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost",user,passwd)
720                        #ANYADIR A LA VARIABLE N4D LAS COSAS INSTALADAS
721                        #self.update_var_dict(N4D_INSTALLED,new_dict)
722                        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])
723                        print COMMENT
724                        return [True,str(COMMENT),result_apt,result_sh[2],result_deb[2],dict_new]
725                except Exception as e:
726                        return[False,str(e)]
727       
728
729
730       
731       
Note: See TracBrowser for help on using the repository browser.