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

Last change on this file since 6497 was 6497, checked in by jrpelegrina, 21 months ago

Fix functions to menu indicator

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