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

Last change on this file since 6247 was 6247, checked in by jrpelegrina, 2 years ago

Fix remote-client to create indicator token

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