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

Last change on this file since 4077 was 4077, checked in by daduve, 4 years ago

Change cache update method

File size: 27.4 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.list"
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       
33       
34        def __init__(self):
35                pass
36               
37        #def __init__
38       
39        def startup(self,options):
40               
41                if os.path.exists(self.file_sources):
42                        os.remove(self.file_sources)
43
44                if options["boot"]:
45                        if options["controlled"]:
46                                if os.system("host server")==0:
47                                        objects["LliureXRemoteInstallerClient"].test_system()
48                                        #test_system(u,"LliureXRemoteInstallerClient")
49                #objects["LliureXRemoteInstallerClient"].test_system()
50       
51        def create_dict (self,mode=[]):
52                try:
53                        #CREACION DEL DICCIONARIO DE LO QUE HEMOS INSTALADO
54                        dict={}
55                        for mod in mode:
56                                dict[mod]=[]
57                                               
58                        COMMENT="[LLXRemoteInstallerClient] (create_dict) Dictionary is created %s"%(dict)
59                        print (COMMENT)
60                        return [True,str(COMMENT),dict]
61                except Exception as e:
62                        print e
63                        return[False,str(e)]
64        #def_create_dict
65       
66        def read_var (self,namevar=None,localhost=None):
67                try:
68                        if localhost in ["",None]:
69                                proxy="https://server:9779"
70                        else:
71                                proxy="https://localhost:9779"
72                        import xmlrpclib as x
73                        c=x.ServerProxy(proxy)
74                        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)
78                        return [True,str(COMMENT),DICT]
79                       
80                except Exception as e:
81                        return [False,str(e)]
82               
83        #def_read_list
84       
85       
86        def initialize_n4dvar(self,list_dict):
87                try:
88                        dict={}
89                        for x in list_dict:
90                                #print "Inicializando...%s"%x
91                                dict[x]={}
92                                if x == self.APT:
93                                        print "Es un apt"
94                                        dict[x]['lliurex']={}
95                                        dict[x]['lliurex'][self.LIST]=[]
96                                        dict[x]['lliurex'][self.URL]=[]
97                                else:
98                                        #print "Es otra cosa....."
99                                        dict[x][self.URL]=[]
100                                        dict[x][self.LIST]=[]
101                        COMMENT=("[LLXRemoteInstallerClient] (initialize_n4dvar) Diccionario inicializado")
102                        print ("%s" %COMMENT)
103                        return [True,str(COMMENT),dict]
104                               
105                except Exception as e:
106                        return [False,str(e)]
107       
108        #def_initialize_var
109       
110       
111       
112        #def test_var (self,namevar=None,localhost=None,user=None,passwd=None):
113        def test_var (self,namevar=None,localhost=None):
114                try:
115                        if localhost in ["",None]:
116                                proxy="https://server:9779"
117                        else:
118                                proxy="https://localhost:9779"
119                               
120                        import xmlrpclib as x
121                        c=x.ServerProxy(proxy)
122                        #u=(user,passwd)
123                        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.........."
127                                list_dict=[self.APT,self.DEB,self.SH]
128                                #VALOR={}
129                                #print list_dict
130                                VALOR=self.create_dict ([self.APT,self.DEB,self.SH])[2]
131                                #VALOR=self.initialize_n4dvar(list_dict)[2]
132                                if objects["VariablesManager"].add_variable(namevar,VALOR,"",namevar,[],False,False)[0]:
133                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Added variable %s to VariablesManager with valor %s" %(namevar,VALOR))
134                                        print ("%s" %COMMENT)
135                                        return [True,str(COMMENT)]
136                                else:
137                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Cannot create it again %s to VariablesManager" %namevar)
138                                        print ("%s" %COMMENT)
139                                        return [True,str(COMMENT)]
140                        else:
141                                COMMENT=("[LLXRemoteInstallerClient] (test_var) %s Variable exists in your system, it hasn't been created again" %namevar)
142                                print ("%s" %COMMENT)
143                                return [True,str(COMMENT)]
144                               
145                except Exception as e:
146                        return [False,str(e)]
147                       
148        #def_test_var
149       
150       
151        def reset_var (self,namevar=None,localhost=None):
152                try:
153                        if localhost in ["",None]:
154                                proxy="https://server:9779"
155                        else:
156                                proxy="https://localhost:9779"
157                        import xmlrpclib as x
158                        c=x.ServerProxy(proxy)
159                        data=None
160                        objects["VariablesManager"].set_variable(namevar,data)
161                        COMMENT=("[LLXRemoteInstallerClient] (reset_var) %s has been updated" %namevar)
162                        print ("%s" %COMMENT)
163                        return [True,str(COMMENT)]
164                               
165                except Exception as e:
166                        return [False,str(e)]
167               
168        #def_reset_var
169
170
171
172        def update_var_dict (self,namevar=None,dict={},localhost=None):
173                try:
174                        if self.test_var(namevar,localhost)[0]:
175                                if localhost in ["",None]:
176                                        proxy="https://server:9779"
177                                else:
178                                        proxy="https://localhost:9779"
179                                import xmlrpclib as x
180                                c=x.ServerProxy(proxy)
181                                objects["VariablesManager"].set_variable(namevar,dict)
182                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) %s has been updated with this list of APP %s" %(namevar,dict)
183                                print ("%s" %COMMENT)
184                                return [True,str(COMMENT)]
185                        else:
186                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) Cannot updated variable"
187                                print ("%s" %COMMENT)
188                                return [False,str(COMMENT)]
189                               
190                except Exception as e:
191                        return [False,str(e)]
192               
193        #def_add_list
194       
195        def download(self, apps=[],url=None,dir=None):
196                try:
197                        #CREATE AUX_SOURCES IF IT'S NECESSARY
198                        if not os.path.exists(dir):
199                                os.makedirs(dir)
200                        for app in apps:
201                                file_app=str(dir)+"/"+app
202                                url_complete=str(url)+str(app)
203                                if os.path.exists(file):
204                                        print "[LLXRemoteInstallerClient] (download) The FILE: %s has been donwloaded before, it will be deleted now."%(file)
205                                        os.remove(file)
206                                print "[LLXRemoteInstallerClient] (download) The FILE: %s is downloading now to directory %s ....."%(app,file_app)
207                                urllib.urlretrieve(url_complete,file_app)
208                                os.chmod(file_app,0755)
209                               
210                        COMMENT="Your FILES: %s has been downloaded in %s"%(apps,dir)
211                        return [True,str(COMMENT)]
212                except Exception as e:
213                        return[False,str(e)]
214       
215        #def_download
216       
217       
218        def repo_add (self,sources_private=None):
219                try:
220                        if sources_private not in ["",None,[]]:
221                                COMMENT="[LLXRemoteInstallerClient](repo_add) REPO IS PARTICULAR %s" %sources_private
222                                print ("%s" %COMMENT)
223                                mode = 'a' if os.path.exists(self.file_sources) else 'w'
224                                f_used=open(self.file_sources,mode)
225                                print "open(%s,%s)"%(self.file_sources,mode)
226                                f_used.write(sources_private+'\n')
227                                f_used.close()
228                                print "[LLXRemoteInstaller](repo_add) File created now read it" 
229                                #NOW READ THE NEW SOURCES.LIST
230                                sources=[]
231                                file=open(self.file_sources)
232                                f=file.read().splitlines()
233                                for line in f:
234                                        sources.append(line)
235                                file.close()
236                       
237                        COMMENT="[LLXRemoteInstallerClient](repo_add) Your repo LLXRemoteInstallerClient has new lines %s"%sources     
238                        print ("%s" %COMMENT)
239                        return [True,str(COMMENT),sources]
240       
241                               
242                except Exception as e:
243                        return [False,str(e)]
244               
245        #def_repo_add
246       
247       
248       
249        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)
254                        if os.path.exists(file):
255                                #print "Borrandoooooooooooooooooooooooooooooo"
256                                os.remove(file)
257                        self.repo_update()
258                       
259                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo from AddApplications has deleted"       
260                        print ("%s" %COMMENT)
261                        return [True,str(COMMENT)]
262                       
263                except Exception as e:
264                        return [False,str(e)]
265               
266        #def_repo_restore
267       
268       
269        def repo_update (self):
270                try:
271                        print "[LLXRemoteInstallerClient](repo_restore) Updating indices, please wait........"
272                        proc = subprocess.Popen('apt-get update', shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
273                        proc.wait()
274                        #self.cache.update()
275                        self.cache=apt.Cache()
276                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Your APT CACHE has updated with new indices"
277                        print ("%s" %COMMENT)
278                        return [True,str(COMMENT)]
279                       
280                except Exception as e:
281                        return [False,str(e)]
282               
283        #def_repo_restore
284       
285               
286        def deb_solvedependence (self,deb=None,list=[]):
287                try:
288                        for s in list:
289                                name_deb=s[0]
290                                version_deb=s[1]
291                                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
294                                if name_deb in self.cache:
295                                        print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence is avaible"
296                                        pkg=self.cache[name_deb]
297                                        #COMPRUEBO QUE ESTA INSTALADA O PIDO QUE SE INSTALE LA DEPENDENCIA
298                                        if pkg.is_installed:
299                                                print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence IS INSTALLED in your system DO NOTHING WITH IT"
300                                        else:
301                                                print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence %s has to been installed now ......"%(name_deb)
302                                                list_deb_aux=[]
303                                                list_deb_aux.append(name_deb)
304                                                self.apt_install(list_deb_aux)
305                                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
308                                        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]
309                                        virtual_deb=False
310                                        #REVISAMOS EL RESULTADO A VER SI ES VIRTUAL
311                                        for line in result.splitlines():
312                                                #print "Test line %s"%line
313                                                if "install" in line:
314                                                        print "[LLXRemoteInstallerClient](deb_solvedependence) Dependence: %s is a virtual package installed in my system"%name_deb
315                                                        virtual_deb=True
316                                        #SOLO DEVOLVEREMOS FALSE SI NO SE CUMPLEN DEPENDENCIAS Y NO ES PAQUETE VIRTUAL
317                                        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
320                                                return[False,str(COMMENT)]
321                       
322                        COMMENT="[LLXRemoteInstallerClient](deb_solvedependence) Your DEPENDENCES has been resolved now you can continue to install your DEB: %s"%(deb)
323                        print COMMENT
324                        return[True,str(COMMENT)]
325                except Exception as e:
326                        return [False,str(e)]
327               
328        #def_debsolvedependence
329       
330       
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
341                                if len(x)<2:
342                                        if self.deb_solvedependence(deb,x)[0] == 'False':
343                                                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
346                                                return[False,str(COMMENT)]
347                                else:
348                                        #TENEMOS UNA DEPENDENCIA DE UN OR CON LO QUE UN SOLO TRUE DE UNA DE LAS DEPENDENCIAS PERMITIRA INSTALAR EL DEB
349                                        OK=False
350                                        print "[LLXRemoteInstallerClient](deb_testdependences)                    Initializing test for *OR* tupla                     "
351                                        for s in x:
352                                                s=[s]
353                                                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
357                                                        OK=True
358                                                        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
362                                                return[False,str(COMMENT)]
363                                        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
368                        return[True,str(COMMENT)]
369                       
370                except Exception as e:
371                        print e
372                        return [False,str(e)]
373               
374        #deb_testdependences
375       
376       
377        def deb_install(self,list_deb=[],dir_deb=None):
378                try:
379                        list_ok=[]
380                        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
384                        for deb in list_deb:
385                                file_deb=str(dir_deb)+"/"+str(deb)
386                                print "[LLXRemoteInstallerClient](deb_install) Test first deb to install: %s in dir: %s"%(deb,file_deb)
387                                app=apt.debfile.DebPackage(file_deb,self.cache)
388                                #COMPRUEBO QUE ES INSTALABLE
389                                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
396                                                app.install()
397                                                list_ok.append(deb)
398                                        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
403                                               
404                                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)
407                                        list_not.append(deb)
408                                                               
409                                       
410                               
411                        COMMENT="The DEBS installed are: %s and DEBS with problems are:%s"%(list_ok, list_not)
412                        return [True,str(COMMENT),list_ok,list_not]
413                except Exception as e:
414                        return[False,str(e)]
415                       
416        #deb_install
417       
418        def sh_install(self,list_sh=[],dir=""):
419                try:
420                        list_ok=[]
421                        list_not=[]
422                        for app in list_sh:
423                                print "[LLXRemoteInstallerClient](sh_install) Working with SCRIPT: %s"%app
424                                file_app=str(dir)+"/"+app
425                                if os.path.exists(file_app):
426                                        print "[LLXRemoteInstallerClient](sh_install) Executing it, please wait.........."
427                                        proc = subprocess.Popen(file_app, shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
428                                        proc.wait()
429                                        lines=subprocess.Popen(["LAGUAGE=en_EN; md5sum %s | awk '{print $1}'"%file_app],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
430                                        for line in lines.splitlines():
431                                                md5=line
432                                        list_ok.append([app,md5])
433                                else:
434                                        print "[LLXRemoteInstallerClient](sh_install) This script not exist in your system."
435                                        list_not.append(app)
436                       
437                        if list_ok not in ["",None,[]]:
438                                COMMENT="Your FILES: %s has been executed"%(list_ok)
439                                return [True,str(COMMENT),list_ok,list_not]
440                        else:
441                                COMMENT="Some script could not executed in your system, please review it %s"%(list_not)
442                                return [True,str(COMMENT),list_ok,list_not]
443                       
444                except Exception as e:
445                        return[False,str(e)]
446                       
447        #sh_install
448       
449        def apt_install(self,list_apt=[]):
450                try:
451                        list_apt_ok=[]
452                        list_apt_not=[]
453                        list_apt_system=[]
454                        print ""
455                        print "############################################################"
456                        for app in list_apt:
457                                print "[LLXRemoteInstallerClient](apt_install) Comprobando si es avaiable e instalable la APP: %s"%app
458                                if app in self.cache:
459                                        pkg=self.cache[app]
460                                        if pkg.is_installed:
461                                                print "[LLXRemoteInstallerClient](apt_install) The APP: %s is intalled in your system"%(app)
462                                                print ""
463                                                list_apt_system.append(app)
464                                        else:
465                                                print "[LLXRemoteInstallerClient](apt_install) The APP: %s wil be installed soon"%(app)
466                                                pkg.mark_install()
467                                                list_apt_ok.append(app)
468                                                list_apt_system.append(app)
469                                                print ""
470                                else:
471                                        list_apt_not.append(app)
472                                               
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........"
476                                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,[]]:
484                                        COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s"%(list_apt)
485                                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 "############################################################"
495                        return [True,str(COMMENT),list_apt_ok,list_apt_not,list_apt_system]
496                               
497                except Exception as e:
498                        return[False,str(e)]
499                       
500        #apt_install
501       
502       
503        def test_system(self):
504                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"
511                        self.test_var(self.N4D_INSTALLED,"localhost")
512                        #print "[LLXRemoteInstallerClient] (test_system) Variablelocal N4D exists, read it"
513                        dict_orig=self.read_var(self.N4D_INSTALLED,"localhost")[2]
514                                       
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"]:
519                                COMMENT="[LLXRemoteInstallerClient](test_system) Variable %s do not exist in your server, do nothing"%self.N4D_VAR     
520                                print ("%s" %COMMENT)
521                                return [True,str(COMMENT)]
522                       
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 ""
532                        dict_orig_aux=dict_orig
533                       
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
689                        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......."
741                        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
746                        return [True,str(COMMENT),result_apt,result_sh[2],result_deb[2],dict_new]
747                except Exception as e:
748                        return[False,str(e)]
749       
750
751
752       
753       
Note: See TracBrowser for help on using the repository browser.