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

Last change on this file since 6001 was 6001, checked in by daduve, 2 years ago

Updating for eliminate bug when test apt failed in server and new comentaries in client debug

File size: 33.4 KB
Line 
1import subprocess
2import os
3import urllib
4import apt
5import apt.debfile
6import types
7import datetime
8import threading
9
10class LliureXRemoteInstallerClient:
11       
12        dir_tmp="/tmp/.LLXRemoteInstallerClient"
13        N4D_VAR="LLX_REMOTE_INSTALLER"
14        N4D_INSTALLED="LLX_REMOTE_INSTALLER_INSTALLED"
15       
16        #REPO ADDAPLICATION_SOURCES value
17        dir_sources="/etc/apt/sources.list.d/"
18        file_sources="llxremoteinstaller_sources.list"
19        file_sources=str(dir_sources)+str(file_sources)
20       
21        #Dict values
22        DEB='deb'
23        APT='apt'
24        SH='sh'
25        LIST='packages'
26        URL='url'
27        UPDATE='update'
28       
29        #Essential package for provides
30        pack_provide="dctrl-tools"
31       
32        #Installed apps
33        LIST_APP_FINAL=[]
34       
35        def __init__(self):
36                self.dbg=0
37               
38                pass
39        #def __init__
40
41        def _print_info(self,message):
42                print("[RemoteInstallerClient] "+str(message))
43
44        def _debug(self,message):
45                self._log(message)
46                if self.dbg==1:
47                        print("RemoteInstallerClient: "+str(message))
48                        self._log(message)
49
50        def _log(self, message):
51                logFile="/tmp/remoteInstall.log"
52                if os.path.exists(logFile):
53                        f=open (logFile,"a")
54                else:
55                        #os.system(touch /tmp/remoteInstall.log)
56                        f=open (logFile,"w")
57                f.write(str(message)+"\n")
58                f.close()
59
60        def startup(self,options):
61                if os.path.exists(self.file_sources):
62                        os.remove(self.file_sources)
63
64                if options["boot"]:
65                        if options["controlled"]:
66                                if os.system("host server")==0:
67                                        try:
68                                                t=threading.Thread(target=self.test_system)
69                                                t.daemon=True
70                                                t.start()
71                                        except Exception as e:
72                                                print e
73
74        #def startup
75       
76        def create_dict (self,mode=[]):
77                try:
78                        #Installed apps dict
79                        dict={}
80                        for mod in mode:
81                                dict[mod]=[]
82                        COMMENT="[LLXRemoteInstallerClient] (create_dict) Dictionary is created %s"%(dict)
83                        print COMMENT
84                        self._debug(COMMENT)
85                        return [True,str(COMMENT),dict]
86                except Exception as e:
87                        print e
88                        return[False,str(e)]
89        #def_create_dict
90       
91        def read_var (self,namevar=None,localhost=None):
92                try:
93#                       if localhost in ["",None]:
94                        if not localhost:
95                                proxy="https://server:9779"
96                        else:
97                                proxy="https://localhost:9779"
98                        import xmlrpclib as x
99                        c=x.ServerProxy(proxy)
100                        DICT=c.get_variable("","VariablesManager",namevar)
101                        COMMENT="[LLXRemoteInstallerClient] (read_var) Value of N4D var %s of %s is %s"%(namevar,proxy,DICT)
102                        self._debug(COMMENT)
103                        return [True,str(COMMENT),DICT]
104                except Exception as e:
105                        return [False,str(e)]
106        #def_read_list
107       
108        def initialize_n4dvar(self,list_dict):
109                self._debug("FNC: initialize_n4dvar")           
110                try:
111                        dict={}
112                        for x in list_dict:
113                                dict[x]={}
114                                if x == self.APT:
115                                        self._debug("Apt mode")
116                                        dict[x]['lliurex']={}
117                                        dict[x]['lliurex'][self.LIST]=[]
118                                        dict[x]['lliurex'][self.URL]=[]
119                                else:
120                                        dict[x][self.URL]=[]
121                                        dict[x][self.LIST]=[]
122                        COMMENT=("[LLXRemoteInstallerClient] (initialize_n4dvar) Dict initialized")
123                        self._debug(COMMENT)
124                        print COMMENT
125                        return [True,str(COMMENT),dict]
126                except Exception as e:
127                        return [False,str(e)]
128       
129        #def_initialize_var
130       
131        #def test_var (self,namevar=None,localhost=None,user=None,passwd=None):
132        def test_var (self,namevar=None,localhost=None):
133                self._debug("test_var")
134                try:
135#                       if localhost in ["",None]:
136                        if not localhost:
137                                proxy="https://server:9779"
138                        else:
139                                proxy="https://localhost:9779"
140                        self._debug("Proxy: "+proxy)
141                        self._debug("Localhost: "+str(localhost))
142                        self._debug("Namevar: "+str(namevar))
143                        import xmlrpclib as x
144                        c=x.ServerProxy(proxy)
145                        VALOR=c.get_variable("","VariablesManager",namevar)
146                        self._debug("[LLXRemoteInstallerClient] (test_var) Value of N4d var "+str(namevar)+" is: "+str(VALOR))
147#                       if  VALOR in [None,'','None']:
148                        if  not VALOR:
149                                list_dict=[self.APT,self.DEB,self.SH,self.UPDATE]
150                                VALOR=self.create_dict ([self.APT,self.DEB,self.SH,self.UPDATE])[2]
151                                if objects["VariablesManager"].add_variable(namevar,VALOR,"",namevar,[],False,False)[0]:
152                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Added variable %s to VariablesManager with valor %s" %(namevar,VALOR))
153                                        self._debug(COMMENT)
154                                        return [True,str(COMMENT)]
155                                else:
156                                        COMMENT = ("[LLXRemoteInstallerClient] (test_var) Cannot create %s again in VariablesManager" %namevar)
157                                        self._debug(COMMENT)
158                                        return [True,str(COMMENT)]
159                        else:
160                                COMMENT=("[LLXRemoteInstallerClient] (test_var) %s Variable exists in your system, it hasn't been created again" %namevar)
161                                self._debug(COMMENT)
162                                return [True,str(COMMENT)]
163                               
164                except Exception as e:
165                        self._debug("ERROR test_var" + str(e))
166                        return [False,str(e)]
167        #def_test_var
168       
169        def reset_var (self,namevar=None,localhost=None):
170                self._debug("reset_var")
171                try:
172#                       if localhost in ["",None]:
173                        if not localhost:
174                                proxy="https://server:9779"
175                        else:
176                                proxy="https://localhost:9779"
177                        import xmlrpclib as x
178                        c=x.ServerProxy(proxy)
179                        data=None
180                        objects["VariablesManager"].set_variable(namevar,data)
181                        COMMENT=("[LLXRemoteInstallerClient] (reset_var) %s has been updated" %namevar)
182                        self._debug(COMMENT)
183                        return [True,str(COMMENT)]
184                               
185                except Exception as e:
186                        return [False,str(e)]
187               
188        #def_reset_var
189
190        def update_var_dict (self,namevar=None,dict={},localhost=None):
191                self._debug("update_var dict")
192                try:
193                        if self.test_var(namevar,localhost)[0]:
194                                if localhost in ["",None]:
195                                        proxy="https://server:9779"
196                                else:
197                                        proxy="https://localhost:9779"
198                                import xmlrpclib as x
199                                c=x.ServerProxy(proxy)
200                                objects["VariablesManager"].set_variable(namevar,dict)
201                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) %s has been updated with this list of APP %s" %(namevar,dict)
202                                self._debug(COMMENT)
203                                return [True,str(COMMENT)]
204                        else:
205                                COMMENT="[LLXRemoteInstallerClient] (update_var_list) Can't update variable"
206                                self._debug(COMMENT)
207                                return [False,str(COMMENT)]
208                except Exception as e:
209                        return [False,str(e)]
210               
211        #def_add_list
212       
213        def download(self, apps=[],url=None,dir=None):
214                try:
215                        #CREATE AUX_SOURCES IF IT'S NECESSARY
216                        if not os.path.exists(dir):
217                                os.makedirs(dir)
218                        for app in apps:
219                                file_app=str(dir)+"/"+app
220                                url_complete=str(url)+str(app)
221                                if os.path.exists(file):
222                                        self._debug("(download) The FILE: "+file+" has been donwloaded before, it will be deleted now.")
223                                        os.remove(file)
224                                self._debug("(download) The FILE: "+app+" is downloading now to directory "+file_app+" .....")
225                                urllib.urlretrieve(url_complete,file_app)
226                                os.chmod(file_app,0755)
227                               
228                        COMMENT="Your FILES: %s has been downloaded in %s"%(apps,dir)
229                        return [True,str(COMMENT)]
230                except Exception as e:
231                        return[False,str(e)]
232       
233        #def_download
234       
235       
236        def repo_add (self,sources_private=None):
237                try:
238                        if sources_private not in ["",None,[]]:
239                                COMMENT="(repo_add) REPO IS PARTICULAR %s" %sources_private
240                                self._debug(COMMENT)
241                                mode = 'a' if os.path.exists(self.file_sources) else 'w'
242                                f_used=open(self.file_sources,mode)
243                                self._debug("open("+self.file_sources+","+mode+")")
244                                f_used.write(sources_private+'\n')
245                                f_used.close()
246                                self._debug("[LLXRemoteInstaller](repo_add) File created now read it")
247                                #NOW READ THE NEW SOURCES.LIST
248                                sources=[]
249                                file=open(self.file_sources)
250                                f=file.read().splitlines()
251                                for line in f:
252                                        sources.append(line)
253                                file.close()
254                       
255                        COMMENT="[LLXRemoteInstallerClient](repo_add) Your repo LLXRemoteInstallerClient has new lines %s"%sources     
256                        self._debug(COMMENT)
257
258                        return [True,str(COMMENT),sources]
259                except Exception as e:
260                        return [False,str(e)]
261               
262        #def_repo_add
263       
264        def repo_restore (self,file=None):
265                self._debug("repo_restore")
266                try:
267                       
268                        COMMENT="(repo_restore) Repo %s to test APT Aplications is deleted and restore to initial state"%file   
269                        self._debug(COMMENT)
270                        if os.path.exists(file):
271                                os.remove(file)
272                        self.repo_update()
273                        #Delete proxy settings
274                        if os.path.exists("/etc/apt/apt.conf.d/98proxySettings"):
275                                os.remove("/etc/apt/apt.conf.d/98proxySettings")
276                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Repo from AddApplications has been deleted"   
277                        #self._debug(COMMENT)
278                        return [True,str(COMMENT)]
279                       
280                except Exception as e:
281                        return [False,str(e)]
282               
283        #def_repo_restore
284       
285        def repo_update (self):
286                self._debug("repo_update")
287                try:
288                        self._debug("(repo_restore) Updating indices, please wait........")
289                        proc = subprocess.Popen('apt-get update', shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
290                        proc.wait()
291                        #self.cache.update()
292                        self.cache=apt.Cache()
293                        COMMENT="[LLXRemoteInstallerClient](repo_restore) Your APT CACHE has updated with new indices"
294                        #self._debug(COMMENT)
295                        return [True,str(COMMENT)]
296                       
297                except Exception as e:
298                        return [False,str(e)]
299               
300        #def_repo_update
301
302        def repo_customize_apt(self,repos=[]):
303                pinFile="/etc/apt/preferences.d/lliurex-pinning"
304                if os.path.exists(pinFile):
305                        f=open(pinFile,'a')
306                        f.write("###\n")
307                        for repo in repos:
308                                arrayRepoDir=repo.split(' ')
309                                repoOrig=arrayRepoDir[1]
310                                pinLine="Package: *\nPin: origin "+repoOrig+"\nPin-Priority:700\n"
311                                f.write(pinLine)
312                        f.close()
313                #Setup proxy in apt.config.d
314                prefFile=open("/etc/apt/apt.conf.d/98proxySettings","w")
315                prefFile.write('Acquire::http::proxy "http://proxy:3128";')
316                prefFile.close()
317        #def repo_customize_apt
318
319        def repo_restore_config(self):
320                pinFile="/etc/apt/preferences.d/lliurex-pinning"
321                if os.path.exists(pinFile):
322                        f=open(pinFile,'r')
323                        lines=f.readlines()
324                        f.close()
325                        defaultPin=[]
326                        continueReading=1
327                        for line in lines:
328                                if continueReading:
329                                        if line!="###\n":
330                                                defaultPin.append(line)
331                                        else:
332                                                continueReading=0
333                                else:
334                                        break
335                        f=open(pinFile,'w')
336                        f.writelines(defaultPin)
337                        f.close()
338                if os.path.exists("/etc/apt/apt.conf.d/98proxySettings"):
339                        os.remove("/etc/apt/apt.conf.d/98proxySettings")
340                self._debug("Default config restored")
341        #def repo_restore_config
342               
343        def deb_solvedDependency (self,deb=None,list=[]):
344                try:
345                        for s in list:
346                                name_deb=s[0]
347                                version_deb=s[1]
348                                test_deb=s[2]
349                                self._debug("(deb_solvedDependency) DEB: "+deb+" depends on package: "+name_deb+" -- version: "+test_deb+" "+version_deb+" -- ")
350                                #Check if exists in cache. If not abort process
351                                if name_deb in self.cache:
352                                        #self._debug("[LLXRemoteInstallerClient](deb_solvedDependency) Dependence is avaible")
353                                        pkg=self.cache[name_deb]
354                                        #Check if installed or install dependency
355                                        if pkg.is_installed:
356                                                self._debug("(deb_solvedDependency) Dependency IS INSTALLED in your system DO NOTHING WITH IT")
357                                        else:
358                                                self._debug("(deb_solvedDependency) Dependency "+name_deb+" is being installed ......")
359                                                list_deb_aux=[]
360                                                list_deb_aux.append(name_deb)
361                                                self.apt_install(list_deb_aux)
362                                else:
363                                        #Check if it's a virtual package from a provides
364                                        self._debug("(deb_solvedDependency) Testing if dependency "+name_deb+" is a virtual package")
365                                        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]
366                                        virtual_deb=False
367                                        for line in result.splitlines():
368                                                if "install" in line:
369                                                        self._debug("(deb_solvedDependency) Dependence: "+name_deb+" is a virtual package installed in my system")
370                                                        virtual_deb=True
371                                        #Abort the process only if dependencies doesn't resolv and it's not a virtual package
372                                        if not virtual_deb:
373                                                COMMENT="[LLXRemoteInstallerClient](deb_solvedDependency) Your DEB: %s has unreliable dependencies: %s can not been installed"%(deb,name_deb)
374                                                #self._debug(COMMENT)
375                                                return[False,str(COMMENT)]
376                       
377                        COMMENT="[LLXRemoteInstallerClient](deb_solvedDependency) Your DEPENDENCIES has been resolved. Now will continue installing: %s"%(deb)
378                        #self._debug(COMMENT)
379                        return[True,str(COMMENT)]
380                except Exception as e:
381                        return [False,str(e)]
382               
383        #def_debsolvedependence
384       
385       
386        def deb_testDependencies(self,deb=None,dependsList=[]):
387                try:
388                        #Check if dependencies are installed
389                        self._debug("(deb_testDependencies) Testing your DEB: "+deb+" against this dependencies list "+str(dependsList))
390                        for x in dependsList:
391                                self._debug("[LLXRemoteInstallerClient](deb_testDependencies) -------------- Testing this tupla "+str(x)+" ------------------")
392                                #If dependency has more than one element is an "OR" dependency. Must resolv one of them
393                                if len(x)<2:
394                                        if self.deb_solvedDependency(deb,x)[0] == 'False':
395                                                name_deb=x[0]
396                                                COMMENT="[LLXRemoteInstallerClient](deb_testDependencies) Your DEB: %s has dependences without solution with your actual repos, APP: %s can not been installed"%(deb,name_deb)
397                                                #self._debug(COMMENT)
398                                                return[False,str(COMMENT)]
399                                else:
400                                        #"OR" Dependency, one "True" is enough
401                                        OK=False
402                                        self._debug("(deb_testDependencies) Initializing test for *OR* tupla")
403                                        for s in x:
404                                                s=[s]
405                                                name_deb=s[0][0]
406                                                if self.deb_solvedDependency(deb,s)[0]:
407                                                        self._debug("(deb_testDependencies) Testing OR tupla: this dependency "+str(name_deb)+" can be installed, as solves the conflict")
408                                                        OK=True
409                                                        ok_solved=s
410                                        if not OK:
411                                                COMMENT="[LLXRemoteInstallerClient](deb_testDependencies) Testing OR tupla: can not resolve this OR dependency for %s"%(x)
412                                                #self._debug(COMMENT)
413                                                return[False,str(COMMENT)]
414                                        else:
415                                                pass
416                                                self._debug("(deb_testDependencies) Testing OR tupla, can install this dependency: "+str(ok_solved)+" and can resolve OR dependency for "+str(x))
417                       
418                        COMMENT="[LLXRemoteInstallerClient](deb_testDependencies) Dependencies are resolved. Now you can install your DEB: %s"%(deb)
419                        #self._debug(COMMENT)
420                        return[True,str(COMMENT)]
421                except Exception as e:
422                        self._debug("ERROR deb_testDependencies: "+str(e))
423                        return [False,str(e)]
424        #deb_testDependencies
425       
426        def deb_install(self,list_deb=[],dir_deb=None):
427                try:
428                        list_ok=[]
429                        list_not=[]
430                        #Load apt cache
431                        self.cache=apt.Cache()
432                        self._debug("(deb_install) CACHE updated")
433                        #Check each deb marked to install
434                        for deb in list_deb:
435                                file_deb=str(dir_deb)+"/"+str(deb)
436                                self._debug("(deb_install) Test first deb to install: "+deb+" in dir: "+file_deb)
437                                app=apt.debfile.DebPackage(file_deb,self.cache)
438                                #Check if it's installable
439                                if app.check():
440                                        self._debug("(deb_install) The deb can be installed, now will proceed to check dependencies, please wait....")
441                                        if self.deb_testDependencies(deb,app.depends)[0]:
442                                                #Install if all is OK
443                                                self._debug("(deb_install) The system are ready to install the DEB: "+deb)
444                                                app.install()
445                                                list_ok.append(deb)
446                                        else:
447                                                #Failed dependencies
448                                                self._debug("(deb_install) The system cannot resolve the dependencies for your deb, review your repos or your DEB if you want to install it: "+deb)
449                                               
450                                else:
451                                        #There's any reason that makes deb uninstallable
452                                        self._debug("(deb_install) Your DEB: "+deb+" cannot be installed in your system")
453                                        list_not.append(deb)
454                               
455                        COMMENT="DEBS installed: %s . DEBS with problems:%s"%(list_ok, list_not)
456                        return [True,str(COMMENT),list_ok,list_not]
457                except Exception as e:
458                        self._debug("(deb_install) ERROR: "+str(e))
459                        return[False,str(e)]
460        #deb_install
461       
462        def sh_install(self,list_sh=[],dir=""):
463                try:
464                        list_ok=[]
465                        list_not=[]
466                        for app in list_sh:
467                                self._debug("(sh_install) Working with SCRIPT: "+app)
468                                file_app=str(dir)+"/"+app
469                                if os.path.exists(file_app):
470                                        self._debug("(sh_install) Executing it, please wait..........")
471                                        proc = subprocess.Popen(file_app, shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
472                                        proc.wait()
473                                        lines=subprocess.Popen(["LAGUAGE=en_EN; md5sum %s | awk '{print $1}'"%file_app],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
474                                        for line in lines.splitlines():
475                                                md5=line
476                                        list_ok.append([app,md5])
477                                else:
478                                        self._debug("(sh_install) The script "+file_app+" not exists in your system.")
479                                        list_not.append(app)
480                       
481#                       if list_ok not in ["",None,[]]:
482                        if list_ok:
483                                COMMENT="Your SCRIPTS: %s had been executed"%(list_ok)
484                                return [True,str(COMMENT),list_ok,list_not]
485                        else:
486                                COMMENT="Some scripts failed to execute, please check them %s"%(list_not)
487                                return [True,str(COMMENT),list_ok,list_not]
488                       
489                except Exception as e:
490                        return[False,str(e)]
491                       
492        #sh_install
493       
494        def apt_install(self,list_apt=[]):
495                self._debug("App List: "+str(list_apt))
496                try:
497                        list_apt_ok=[]
498                        list_apt_not=[]
499                        list_apt_system=[]
500                        self._debug("(apt_install) Apps list: "+str(list_apt))
501                        for app in list_apt:
502                                self._debug("(apt_install) Checking if app "+app+" is available and installable")
503                                if app in self.cache:
504                                        pkg=self.cache[app]
505                                        if pkg.is_installed:
506                                                self._debug("(apt_install) The APP: "+app+" is intalled in your system")
507                                                list_apt_system.append(app)
508                                        else:
509                                                self._debug("(apt_install) The APP: "+app+" wil be installed soon")
510                                                pkg.mark_install()
511                                                list_apt_ok.append(app)
512#                                               list_apt_system.append(app)
513                                else:
514                                        list_apt_not.append(app)
515                                               
516                        if list_apt_ok:
517                                        #                               self._debug("(apt_install) Please wait while installing: "+str(list_apt_ok))
518                                self._debug("(apt_install) Please wait while installing: "+str(list_apt_ok))
519                                self.cache.commit()
520#                               if list_apt_not in ["",None,[]]:
521                                if not list_apt_not:
522                                        COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s"%(list_apt_system)
523                                else:
524                                        COMMENT="[LLXRemoteInstallerClient](apt_install) The system has been updated with this APP list: %s but this list cann't be installed:%s"%(list_apt_ok, list_apt_not)
525                        else:
526#                               if list_apt_not in ["",None,[]]:
527                                if not list_apt_not:
528                                        COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s"%(list_apt)
529                                else:
530                                        COMMENT="[LLXRemoteInstallerClient](apt_install) Do nothing, because your system has installed all APP in list: %s and this list cannot be installed because your REPO do not have it:%s"%(list_apt_system, list_apt_not)
531                       
532#                       if list_apt_system not in ["",None,[]]:
533                        if list_apt_ok:
534                                for app in list_apt_ok:
535                                        self._debug("[LLXRemoteInstallerClient](apt_install) The APP: "+app+" is intalled in your system.....Adding to installed list")
536#                                       list_apt_ok.append(app)
537                        self._debug(COMMENT)
538                        self._debug(str(list_apt_ok)+"  ---  "+str(list_apt_not)+"  ---  "+str(list_apt_system))
539                        return [True,str(COMMENT),list_apt_ok,list_apt_not,list_apt_system]
540                               
541                except Exception as e:
542                        return[False,str(e)]
543                       
544        #apt_install
545
546        def deb_test(self,appDict,dictOrig):
547                self._debug("deb_test")
548                #Get dict values
549                list_deb=appDict[self.LIST]
550                url_deb=appDict[self.URL]
551
552                #Create download path
553                dir_deb=str(self.dir_tmp)+"/"+"deb"
554                #Check if the deb is installed
555                deb_aux=[]
556                self._debug("(test_system) Checking if any deb on the list is already installed "+str(list_deb))
557                for deb in list_deb:
558                        if deb not in dictOrig:
559                                self._debug("(test_system)DEB: "+deb+" marked for install")
560                                deb_aux.append(deb)
561                        else:
562                                pass
563                                self._debug("(test_system)DEB: "+deb+" is already installed")
564                list_deb=deb_aux
565                #Download needed debs
566#               if list_deb not in ["",None,[]]:
567                if list_deb:
568                        self._debug("(test_system) Debs list is "+str(list_deb)+" Download path is: "+url_deb)
569                        self.download(list_deb,url_deb,dir_deb)
570                        result_deb=self.deb_install(list_deb,dir_deb)
571                       
572                else:
573                        self._debug("(test_system) Deb list is empty")
574                        result_deb=["","","","",""]
575                return(result_deb)
576        #def deb_test
577
578        def sh_test(self,appDict,dictOrig):
579                self._debug("sh_test")
580                #Get dict values
581                list_sh=appDict[self.LIST]
582                url_sh=appDict[self.URL]
583                #Create donwload path and download needed scripts
584                dir_sh=str(self.dir_tmp)+"/"+"scripts"
585                self._debug("Created tmp dir "+dir_sh)
586#               if list_sh not in ["",None,[]]:
587                if list_sh:
588                        sh_aux=[]
589                        for sh_tupla in list_sh:
590                                sh=sh_tupla[0]
591                                md5=sh_tupla[1]
592                                if sh_tupla not in dictOrig:
593                                        self._debug("(test_system) SH: must install "+sh)
594                                        sh_aux.append(sh)
595                                else:
596                                        self._debug("(test_system) SH: "+sh+" already installed")
597                        #Download and execute the scripts
598                        list_sh=sh_aux 
599                        self._debug("(test_system) Script list is "+str(list_sh)+" Download to: "+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                                self._debug("(test_system) Script list is empty")
605                                result_sh=["","","","",""]
606                       
607                else:
608                        self._debug("(test_system) Script list is empty")
609                        result_sh=["","","","",""]
610                return(result_sh)
611        #def sh_test
612       
613       
614       
615       
616        def update_test(self,appDict,dictOrig):
617               
618                self._debug("update_test")
619                updated="False"
620                #Get dict values
621                try:
622                        updateDict=appDict[self.UPDATE]
623                except:
624                        self._debug("[LLXRemoteInstallerClient](update_test) Update Test: Creating new dictionary")
625                        version_installed=subprocess.Popen(["lliurex-version -n"],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
626                        version_installed=version_installed.split()[0]
627                        updateDict={'version':version_installed,'datetime':"None",'url':"Mirror"}
628               
629                self._debug("[LLXRemoteInstallerClient](update_test) Update Test: Starting......")
630                       
631                version_installed=subprocess.Popen(["lliurex-version -n"],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
632                version_installed=version_installed.split()[0]
633                version_programed=appDict[self.UPDATE]['version']
634                version_programed=version_programed.split()[0]
635               
636                self._debug("[LLXRemoteInstallerClient](update_test) Update Test: Version installed %s"%version_installed)
637                self._debug("[LLXRemoteInstallerClient](update_test) Update Test: Version programed %s"%version_programed)
638               
639                if ( version_installed < version_programed ):
640                        #actualizo repos y updateo
641                        if appDict[self.UPDATE]['url']=='Lliurex.net':
642                                self._debug("[LLXRemoteInstallerClient](update_test) Updating your system to Lliurex.net, please wait........")
643                                #proc = subprocess.Popen(["lliurex-upgrade -u -r"],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()
644                                #ret=os.system("http_proxy=http://proxy:3128 /usr/sbin/lliurex-upgrade -u -r 2>/dev/null 1>/dev/null")
645                                #ret=int(ret)
646                                proc = subprocess.Popen('http_proxy=http://proxy:3128 /usr/sbin/lliurex-upgrade -u -r', shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
647                                proc.wait()
648                                date=datetime.datetime.now()
649                                date_update=date.strftime("%d-%m-%Y %H:%M:%S")
650                                self._debug("[LLXRemoteInstallerClient](update_test) Actualizacion terminada...... %s"%date_update)
651                                if proc.returncode == 1:
652                                        self._debug("[LLXRemoteInstallerClient](update_test) Fallo actulalizacion")
653                        else:
654                                proc = subprocess.Popen('http_proxy=http://proxy:3128 /usr/sbin/lliurex-upgrade -u', shell=True, stdin=None, stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
655                                proc.wait()
656                                date=datetime.datetime.now()
657                                date_update=date.strftime("%d-%m-%Y %H:%M:%S")
658                                self._debug("[LLXRemoteInstallerClient](update_test) Actualizacion terminada...... %s"%date_update)
659                                if proc.returncode == 1:
660                                        self._debug("[LLXRemoteInstallerClient](update_test) Fallo actulalizacion")
661                       
662                        updated="True"
663                        update_url=appDict[self.UPDATE]['url']
664                        new_version=subprocess.Popen(["lliurex-version -n"],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
665                        new_version=new_version.split()[0]
666                        date=datetime.datetime.now()
667                        date_update=date.strftime("%d-%m-%Y %H:%M")
668                        updateDict={'version':new_version,'datetime':date_update,'url':update_url}
669               
670                if updated == 'True':
671                        self._debug("[LLXRemoteInstallerClient](update_test) Update Test: New dict %s"%updateDict)
672                else:
673                        self._debug("[LLXRemoteInstallerClient](update_test) Updated is not necessary, your system has the required version")
674               
675                return [updateDict, updated]
676               
677        #def deb_test
678
679
680
681        def _refine_apt_repoList(self,appDict,dictOrig):
682                self._debug("_refine_apt_repoList")
683                repoList=[]
684                list_apt=[]
685                lliurex_net=["deb http://lliurex.net/xenial xenial main restricted universe multiverse","deb http://lliurex.net/xenial xenial-security main restricted universe multiverse","deb http://lliurex.net/xenial xenial-updates main restricted universe multiverse"]
686                lliurex_mirror=["deb http://mirror/llx16 xenial main restricted universe multiverse","deb http://mirror/llx16 xenial-security main restricted universe multiverse","deb http://mirror/llx16 xenial-updates main restricted universe multiverse"]
687                for source in appDict:
688                        self._debug("[LLXRemoteInstallerClient](_refine_apt_repoList) Adding applist from: "+str(source))
689                        aux_list_apt=appDict[source][self.LIST]
690                        self._debug("[LLXRemoteInstallerClient](_refine_apt_repoList) Adding PPA: "+str(source))
691                        url=appDict[source][self.URL]
692                        apt_aux=[]
693                        self._debug("(_refine_apt_repoList) Checking if apt list is installed "+str(aux_list_apt))
694                        for apt in aux_list_apt:
695                                if apt not in dictOrig:
696                                        self._debug("(_refine_apt_repoList) Must install APT: "+apt)
697                                        apt_aux.append(apt)
698                                else:
699                                        self._debug("(_refine_apt_repoList) "+apt+" is installed")
700                        #Add non installed debs to list
701                        list_apt.extend(apt_aux)
702                        #configure pinning for new repos
703                        if source in ["LliureX"]:
704                                repoList.extend(lliurex_net)
705                        elif source in ["Mirror"]:
706                                repoList.extend(lliurex_mirror)
707                        else:
708                                repoList.append(url)
709                appsRepoDict={'apt':list_apt,'repos':repoList}
710                return appsRepoDict
711        #def _refine_apt_repoList
712
713        def apt_test(self,appDict,dict_orig):
714                self._debug("apt_test")
715                #Get dict values
716                list_apt_resume=[]
717                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"]
718                list_apt=[]
719                result_apt=["","","","",""]
720                #List with repos for pinning customize
721                repoList=ubuntu
722                #Get debs and repos
723                appsRepoDict=self._refine_apt_repoList(appDict[self.APT],dict_orig[self.APT])
724                repoList.extend(appsRepoDict['repos'])
725                list_apt=appsRepoDict['apt']
726                self.repo_customize_apt(repoList)       
727                if list_apt:
728                        for url in repoList:
729                                if self.repo_add(url):
730                                        self._debug("(test_system) New REPO has been added to your system")
731                        if self.repo_update():
732                                self._debug("[LLXRemoteInstallerClient](apt_test) Your CACHE has been updated")
733                        else:
734#                               return [False,"failed repo_update"]
735                                return result_apt
736                else:
737#                       return [False,"failed repo_add"]
738                        return result_apt
739                        #Proceed with the list, repos are updated
740                self._debug("[LLXRemoteInstallerClient](apt_test) Calling apt_install with "+str(list_apt))
741                result_apt=self.apt_install(list_apt)[2]
742                if result_apt:
743                        for app in result_apt:
744                                list_apt_resume.append(app)
745                                #Delete repo if was created by us
746                        self._debug("Call repo_restore")
747                        self.repo_restore(self.file_sources)
748                else:
749                        self._debug( "[LLXRemoteInstallerClient](apt_test) No apps installed")
750                        result_apt=["","","","",""]
751
752                #Restore default config
753                self._debug("Call repo_restore_config")
754                self.repo_restore_config()     
755                result_apt=list_apt_resume
756                return(result_apt)
757        #def apt_test
758
759        def _update_results(self,dict_orig,result_deb,result_sh,result_apt,result_update,updated):
760                if not dict_orig:
761                        #Create dict if doesn't exists
762                        self._debug("[LLXRemoteInstallerClient](_update_results) Creando el diccionario.......")
763                        dict_new=self.create_dict ([self.APT,self.DEB,self.SH,self.UPDATE])[2]
764                        dict_new[self.APT]=list(result_apt)
765                        dict_new[self.DEB]=list(result_deb[2])
766                        dict_new[self.SH]=list(result_sh[2])
767                        dict_new[self.UPDATE]=result_update
768                        self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost")
769                else:
770                        #Update dict
771                        try:
772                                updateDict=dict_orig[self.UPDATE]
773                        except:
774                                self._debug("Update Result: Creating new dictionarie")
775                                version_installed=subprocess.Popen(["lliurex-version -n"],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[0]
776                                version_installed=version_installed.split()[0]
777                                updateDict={'version':version_installed,'datetime':"None",'url':"Mirror"}
778                                dict_orig[self.UPDATE]=[]
779                                dict_orig[self.UPDATE]=updateDict
780                               
781                       
782                        dict_new=dict_orig
783                        log="[LLXRemoteInstallerClient](_update_results) Will add APT: %s ** DEBS: %s ** SH: %s ** UPDATE: %s "%(result_apt,result_deb[2],result_sh[2],result_update)
784                        self._debug(log)
785                        #Check the dict against a tuple
786                        dict_help=self.create_dict ([self.APT,self.DEB,self.SH,self.UPDATE])[2]
787                        dict_help[self.APT]=list(result_apt)
788                        dict_help[self.DEB]=list(result_deb[2])
789                        dict_help[self.SH]=list(result_sh[2])
790                        #dict_help[self.UPDATE]=result_update
791                        #self._debug("[LLXRemoteInstallerClient](test_system) dict to compare is "+str(dict_help))
792                        #Check values
793                        if updated == 'True':
794                                log="[LLXRemoteInstallerClient](_update_results) System has been updated to version: %s"%result_update['version']
795                                self._debug(log)
796                                dict_new[self.UPDATE]=result_update
797                        for valor_dict in dict_help:
798                                self._debug("[LLXRemoteInstallerClient](_update_results) Test APP from: "+valor_dict)
799                                try:
800                                        for app_installed in dict_help[valor_dict]:
801                                                ok=False
802                                                self._debug("[LLXRemoteInstallerClient](_update_results) Check if app is installed: "+str(app_installed))
803                                                for app_history in dict_orig[valor_dict]:
804                                                        log="[LLXRemoteInstallerClient](_update_results)  APP Installed: %s -- TESTING -- APP System: %s"%(app_installed,app_history)
805                                                        self._debug(log)
806                                                        if app_history == app_installed:
807                                                                self._debug("[LLXRemoteInstallerClient](_update_results) App exists, don't add to dict")
808                                                                ok=True
809                                                if not ok:
810                                                        log="[LLXRemoteInstallerClient](_update_results) Adding app to list: %s"%app_installed
811                                                        self._debug(log)
812                                                        dict_new[valor_dict].append(app_installed)
813                                                else:
814                                                        log="[LLXRemoteInstallerClient](_update_results) App hasn't been added to dict: %s"%app_installed
815                                                        self._debug(log)
816                                except Exception as e:
817                                        self._debug("ERROR: "+str(e))
818                return (dict_new)
819        #def _update_results
820
821        def test_system(self):
822                try:
823                        logFile="/tmp/remoteInstall.log"
824                        if os.path.exists(logFile):
825                                f=open (logFile,"a")
826                                f.write("\n")
827                                f.write("\n")
828                                f.write("-----------------------INIT--------------------\n")
829                                f.close()
830                        #Get installed apps dict
831                        self.test_var(self.N4D_INSTALLED,"localhost")
832                        dict_orig=self.read_var(self.N4D_INSTALLED,"localhost")[2]
833                        #print dict_orig
834                        #Get server dict
835                        appDict=self.read_var(self.N4D_VAR)[2]
836                        #Check the server's dict for install
837                        #if appDict in ["",None,"None"]:
838                        #print appDict
839                        if not appDict:
840                                COMMENT="[LLXRemoteInstallerClient](test_system) Variable %s do not exist in your server, do nothing"%self.N4D_VAR     
841                                self._debug(COMMENT)
842                                return [True,str(COMMENT)]
843                        self._debug("[LLXRemoteInstallerClient] (test_system) The DICTIONARY to use is: "+str(appDict))
844                        self._debug("[LLXRemoteInstallerClient] (test_system) The DICTIONARY installed in your system is: "+str(dict_orig))
845
846                        dict_orig_aux=dict_orig
847                       
848                       
849                        #TEST Debs
850                        self._debug("------------------------------------------------------------------")
851                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> call DEB_test")
852                        result_deb=self.deb_test(appDict[self.DEB],dict_orig[self.DEB])
853                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> end DEB_test <-----")
854                        #TEST SH
855                        self._debug("------------------------------------------------------------------")
856                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> call SH_test")
857                        result_sh=self.sh_test(appDict[self.SH],dict_orig[self.SH])
858                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> end SH_test <-----")
859                        #TEST Apt
860                        self._debug("------------------------------------------------------------------")
861                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> call APT_test")
862                        result_apt=self.apt_test(appDict,dict_orig)
863                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> end APT_test <-----")
864                        #TEST UPDATE
865                        self._debug("------------------------------------------------------------------")
866                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> call UPDATE_test")
867                        if appDict[self.UPDATE]['activate']=="True":
868                                try:
869                                        result_update_vector=self.update_test(appDict,dict_orig)
870                                        #print result_update_vector
871                                        result_update=result_update_vector[0]
872                                        #print result_update
873                                        updated=result_update_vector[1]
874                                        #print updated
875                                except Exception as e:
876                                        print e,"appDict"
877                        else:
878                                result_update={'version':dict_orig[self.UPDATE]['version'],'url':dict_orig[self.UPDATE]['url'],'datetime':dict_orig[self.UPDATE]['datetime']}
879                                updated="False"
880                        self._debug("[LLXRemoteInstallerClient] (test_system) Updated is necessary??? : %s"%updated)
881                        print "Updated is %s"%updated
882                        self._debug("[LLXRemoteInstallerClient] (test_system) -----> end UPDATE_test <---")
883                        #Check that it's a list
884                        sh_installed=list(result_sh[2])
885                        #Add results to N4D dict
886                        dict_new=self._update_results(dict_orig,result_deb,result_sh,result_apt,result_update,updated)
887#                       if dict_orig in ["",None,{}]:
888                        log="[LLXRemoteInstallerClient] (test_system) Dict now is %s"%dict_new
889                        #print log
890                        self._debug(log)
891                        self._debug("[LLXRemoteInstallerClient] (test_system) Updating N4D Variable.......")
892                        #Add installed apps to N4D
893                        self.update_var_dict (self.N4D_INSTALLED,dict_new,"localhost")
894                        if updated == 'False':
895                                COMMENT="The system has been configured with the APPS: %s * has executed the scripts: %s * Installed new DEBS: %s"%(result_apt,sh_installed,result_deb[2])
896                        else:
897                                COMMENT="The system has been configured with the APPS: %s * has executed the scripts: %s * Installed new DEBS: %s * Updated to: %s"%(result_apt,sh_installed,result_deb[2],result_update['version'])
898                        self._debug(COMMENT)
899                        #print COMMENT
900                        return [True,str(COMMENT),result_apt,result_sh[2],result_deb[2],updated,dict_new]
901                except Exception as e:
902                        print e,"!!!!!!!!!!"
903                        return[False,str(e)]
904       
Note: See TracBrowser for help on using the repository browser.