source: lliurex-up/trunk/fuentes/python-lliurex-up/lliurex/lliurexup/__init__.py @ 7449

Last change on this file since 7449 was 7449, checked in by jrpelegrina, 18 months ago

Wip in integration with dpkg-unlocker

File size: 25.0 KB
RevLine 
[3254]1import xmlrpclib 
2import os
3import shutil
4import subprocess
5import socket
6import distutils.dir_util
[3525]7import urllib2
[4461]8import time
[7449]9import psutil
10import struct, fcntl
[3254]11
[4461]12
[3254]13class LliurexUpCore(object):
14        """docstring for LliurexUpCore"""
15        def __init__(self):
16                super(LliurexUpCore, self).__init__()
[3514]17                self.flavourReference=["lliurex-meta-server","lliurex-meta-client", "lliurex-meta-desktop", "lliurex-meta-music", "lliurex-meta-pyme", "lliurex-meta-infantil"] 
[3254]18                self.defaultMirror = 'llx16'
19                self.defaultVersion = 'xenial'
[3690]20                self.lockTokenPath="/var/run/lliurexUp.lock"
[3254]21                self.processPath = '/var/run/lliurex-up'
[3449]22                self.sourcesListPath='/etc/apt/'
[3254]23                self.changelogsPath = os.path.join(self.processPath,'changelogs')
24                self.processSourceslist = os.path.join(self.processPath,'sourceslist')
[3514]25                self.origsourcesfile=os.path.join(self.sourcesListPath,"sources.list")
26                self.origsourcesfileback=os.path.join(self.sourcesListPath,"lliurexup_sources.list")
[3254]27                self.targetMetapackagePath=os.path.join(self.processPath,"targetMetapackage")
28                self.previousflavourspath = os.path.join(self.processPath,'previousflavours')
[3449]29                self.errorpostaction_token=os.path.join(self.processPath,'errorpostaction_token')
[4069]30                self.errorfinalmetapackage_token=os.path.join(self.processPath,'errorfinalmetapackage_token')
[3449]31                self.errorupgrade_token=os.path.join(self.processPath,'errorupgrade_token')
32                self.finalupgrade_token=os.path.join(self.processPath,'finalupgrade_token')
33
[3254]34                self.initActionsPath='/usr/share/lliurex-up/initActions'
35                self.preActionsPath = '/usr/share/lliurex-up/preActions'
36                self.postActionsPath = '/usr/share/lliurex-up/postActions'
37
[7449]38        #def __init__   
39
40        def startLliurexUp(self):
41
[3690]42                self.createLockToken()
[4468]43                self.retryN4d=True
44                self.n4dStatus=True
[3254]45                self.n4d = xmlrpclib.ServerProxy('https://localhost:9779')
[4461]46                self.checkN4dStatus()
[3254]47                self.haveLliurexMirror = False
48                self.metapackageRef=[]
[3542]49                self.previousFlavours = []
[3690]50
[4461]51               
[3254]52                self.getTargetMetapackage()
53                self.flavours = []
[3542]54                self.getPreviousFlavours()
[4461]55               
[4468]56                if self.n4dStatus:
[4461]57                        if len(self.n4d.get_methods('MirrorManager')) > 0:
58                                self.haveLliurexMirror = True
59                       
[4506]60                self.retryN4d=True
[3254]61                self.prepareEnvironment()
62
[7449]63        #def startLliurexUp     
[3690]64
[7449]65        def isLliurexUpLocked(self):
66
67                '''
68                 0: Lliurex-Up is not running
69                 1: Lliurex-Up is running
70                 2: Lliurex-Up is locked for previous failed process
71                 ''' 
72
73                if os.path.exists(self.lockTokenPath):
74                        f=open(self.lockTokenPath,'r')
75                        up_pid=f.readline().split('\n')[0]
76                        if up_pid !="":
77                                up_pid=int(up_pid)
78                                check_pid=psutil.pid_exists(up_pid)
79                                if check_pid:
80                                        code=1
81                                else:
82                                        code=2
83                        else:
84                                code=1
85                               
86                else:
87                        code=0
88
89                return code     
90
91        #def isLliurexUpLocked         
92
93        def isAptLocked(self):
94
95                '''
96                 0: Apt is not running
97                 1: Apt is running
98                 2: Apt is locked for previous failed process
99                 ''' 
100
101                f= open("/var/lib/apt/lists/lock", 'w')
102                try:
103                        fcntl.lockf(f, fcntl.LOCK_EX|fcntl.LOCK_NB)
104                        code=0
105                except IOError:
106                        apt_run=self.find_process("apt-get")
107                        if apt_run!=None:
108                                code =1
109                        else:
110                                code=2
111
112                return code     
113
114
115        #def isAptLocked
116               
117        def isDpkgLocked(self):
118
119                '''
120                 0: Dpkgis not running
121                 1: Dpkg is running
122                 2: Dpkg is locked for previous failed process
123                 3: Apt is running
124
125                 ''' 
126
127                f= open("/var/lib/dpkg/lock", 'w')
128                try:
129                        fcntl.lockf(f, fcntl.LOCK_EX|fcntl.LOCK_NB)
130                        code=0
131                except IOError:
132                        dpkg_run=self.find_process("dpkg")
133                        if dpkg_run!=None:
134                                code =1
135                        else:
136                                apt_run=self.find_process("apt-get")
137                                if apt_run!=None:
138                                        code=3
139                                else:
140                                        code=2 
141
142                return code             
143                       
144
145        #def isAptLocked                       
146
147        def unlockerCommand(self):
148
149
150                return "/usr/sbin/dpkg-unlocker-cli unlock -u"
151
152        #def unlockeCommand                             
153
154
[3690]155        def createLockToken(self):
156
157                if not os.path.exists(self.lockTokenPath):
158                        f=open(self.lockTokenPath,'w')
[7387]159                        up_pid=os.getpid()
160                        f.write(str(up_pid))
[6197]161                        f.close()
[3690]162
[7449]163        #def createLockToken           
164
[3542]165        def getPreviousFlavours(self):
[3254]166               
167                if os.path.exists(self.previousflavourspath):
168                        aux = open(self.previousflavourspath,'r')
169                        lines = aux.readlines()
170                        for x in lines:
[3542]171                                self.previousFlavours.append(x.strip())
[3254]172                        aux.close()
173
[7449]174        #def getPreviousFlavours               
175
[4461]176        def checkN4dStatus(self):
177       
[4506]178                checkStatus=True
[4461]179                cmd='systemctl status n4d.service 1>/dev/null'
180                result=os.system(cmd)
[3254]181
[4461]182                if result !=0:
[4468]183                        if self.retryN4d:
184                                self.retryN4d=False
185                                try: 
186                                        cmd='systemctl restart n4d.service 1>/dev/null'
[4506]187                                        restart=os.system(cmd)
188                                        time.sleep(5)
189                                        if restart ==0:
190                                                self.checkN4dStatus()
191                                        else:
192                                                self.n4dStatus=False
193                                                                                               
[4468]194                                except Exception as e:
[4506]195                                        self.n4dStatus=False
196                                       
197                                       
[4468]198                        else:
[4506]199                                self.n4dStatus=False
200                               
201                                                                               
202                else:           
203                        self.n4dStatus=True
[7449]204
205        #def checkN4dStatus             
[4506]206                       
207                               
[3254]208        def getTargetMetapackage(self):
209
210                if os.path.exists(self.targetMetapackagePath):
211                        aux = open(self.targetMetapackagePath,'r')
212                        lines = aux.readlines()
213                        for x in lines:
214                                self.metapackageRef.append(x.strip())
215                        aux.close()             
216
[7449]217        #def getTargetMetapackage
218                       
[3254]219        def saveTargetMetapackage(self,targetMetapackage):
220
221                aux=open(self.targetMetapackagePath,'w')
222                x=targetMetapackage.split("-")[2]
223                aux.write(x+"\n")
224                x="edu"
225                aux.write(x+"\n")
226                aux.close()
[3449]227
[7449]228        #def saveTargetMetapackage     
[3449]229
[4753]230        def checkInitialFlavour(self,args=None):
[3449]231
232                self.targetMetapackage=self.checkFlavour()
233                if len(self.metapackageRef)==0:
234                        self.getTargetMetapackage()
235               
236                self.metapackageRef=sorted(self.metapackageRef) 
237                         
[3542]238                if len(self.previousFlavours)==0:
239                        self.getPreviousFlavours()
[3254]240               
[3690]241
242                self.writeDefaultSourceslist()
243                self.writeDefaultSourceslistMirror()
[4753]244                self.writeDefaultSourceslistAll()
[3254]245
[4753]246                self.addSourcesListLliurex(args)
247
[3449]248                return self.targetMetapackage
[7449]249
250        #def checkInitialFlavour       
[3449]251               
[3254]252        def updateFlavoursList(self):
[3735]253               
[4563]254                #self.flavours = [ x.strip() for x in self.n4d.lliurex_version('','LliurexVersion','-v')[1].split(',') ]
255                cmd='lliurex-version -v'
256                p=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
257                result=p.communicate()
258                self.flavours = [ x.strip() for x in result[0].split(',') ]
259
[3254]260                if len(self.flavours) > 0:
261                        aux = open(self.previousflavourspath,'w')
262                        for x in self.flavours:
263                                aux.write(x+"\n")
264                        aux.close()
265
[7449]266        #def updateFlavoursList         
267
[3254]268        def writeDefaultSourceslist(self):
[3690]269
[3254]270                f = open(os.path.join(self.processSourceslist,'default'),'w')
[3449]271                f.write('deb http://lliurex.net/{version} {version} main restricted universe multiverse\n'.format(version=self.defaultVersion))
272                f.write('deb http://lliurex.net/{version} {version}-updates main restricted universe multiverse\n'.format(version=self.defaultVersion))
273                f.write('deb http://lliurex.net/{version} {version}-security main restricted universe multiverse\n'.format(version=self.defaultVersion))
[3254]274                f.close()
275
[7449]276        #def writeDefaultSourceslist   
277
[3493]278        def writeDefaultSourceslistMirror(self):
[3735]279               
[3493]280                f = open(os.path.join(self.processSourceslist,'default_mirror'),'w')
281                f.write('deb http://mirror/{version_mirror} {version} main restricted universe multiverse\n'.format(version_mirror=self.defaultMirror,version=self.defaultVersion))
282                f.write('deb http://mirror/{version_mirror} {version}-updates main restricted universe multiverse\n'.format(version_mirror=self.defaultMirror,version=self.defaultVersion))
283                f.write('deb http://mirror/{version_mirror} {version}-security main restricted universe multiverse\n'.format(version_mirror=self.defaultMirror,version=self.defaultVersion))
284                f.close()       
285
[7449]286        #def writeDefaultSourceslistMirror     
[4753]287
[7449]288
[4753]289        def writeDefaultSourceslistAll(self):
290               
291                f = open(os.path.join(self.processSourceslist,'default_all'),'w')
292                f.write('deb http://mirror/{version_mirror} {version} main restricted universe multiverse\n'.format(version_mirror=self.defaultMirror,version=self.defaultVersion))
293                f.write('deb http://mirror/{version_mirror} {version}-updates main restricted universe multiverse\n'.format(version_mirror=self.defaultMirror,version=self.defaultVersion))
294                f.write('deb http://mirror/{version_mirror} {version}-security main restricted universe multiverse\n'.format(version_mirror=self.defaultMirror,version=self.defaultVersion))
295                f.write('deb http://lliurex.net/{version} {version} main restricted universe multiverse\n'.format(version=self.defaultVersion))
296                f.write('deb http://lliurex.net/{version} {version}-updates main restricted universe multiverse\n'.format(version=self.defaultVersion))
297                f.write('deb http://lliurex.net/{version} {version}-security main restricted universe multiverse\n'.format(version=self.defaultVersion))
[7449]298                f.close()       
[4753]299
[7449]300        #def writeDefaultSourceslistAll         
301
[3254]302        def prepareEnvironment(self):
303                '''
304                        This funcion delete all environment and rebuild environment
[3525]305
[3254]306                '''
[3525]307                self.cleanEnvironment()
[3254]308                if not os.path.exists(self.processPath):
309                        os.mkdir(self.processPath)
310                if not os.path.exists(self.processSourceslist):
311                        os.mkdir(self.processSourceslist)
312                if not os.path.exists(self.changelogsPath):
313                        os.mkdir(self.changelogsPath)
[3514]314
[3690]315                #self.writeDefaultSourceslist()
316                #self.writeDefaultSourceslistMirror()
[3254]317
[7449]318        #def prepareEnvironment
319
[4753]320        def addSourcesListLliurex(self,args=None):
[3449]321               
[3690]322                #sourcesrefmirror=os.path.join(self.processSourceslist, 'default_mirror')
[3493]323
[3449]324                newsourcesfile=os.path.join(self.sourcesListPath,'sources.list')
325                extrasources=[]
[4753]326                client=False
327                textsearch_mirror="/mirror/"+str(self.defaultMirror)
328                textsearch_lliurex="/lliurex.net/"+str(self.defaultVersion)
[3449]329
330
[3542]331                if self.targetMetapackage=="lliurex-meta-client" or "client" in self.previousFlavours or "client" in self.metapackageRef:
[4753]332                        client=True
333                        if args:
334                                sourcesref=os.path.join(self.processSourceslist, 'default_all')
[3493]335
[4753]336                        else:
337                                #textsearch="/mirror/"+str(self.defaultMirror)
338                                sourcesref=os.path.join(self.processSourceslist, 'default_mirror')
339
[3493]340                else:
[4753]341                        #textsearch="/lliurex.net/"+str(self.defaultVersion)
[3493]342                        sourcesref=os.path.join(self.processSourceslist, 'default')     
343
344                if os.path.exists(self.origsourcesfile):
345                        os.rename(self.origsourcesfile,self.origsourcesfileback)
346                        origsources=open(self.origsourcesfileback,'r')
[4753]347                        if not client:
348                                for line in origsources:
349                                        if not textsearch_lliurex in line:
350                                                extrasources.append(line.strip())
351                        else:
352                                for line in origsources:
353                                        if args:
354                                                if (not textsearch_lliurex in line) and (not textsearch_mirror in line):
355                                                        extrasources.append(line.strip())
356                                        else:
357                                                if not textsearch_mirror in line:
358                                                        extrasources.append(line.strip())               
359                                                                                               
360
[3493]361                        origsources.close()
[3449]362                               
363                        if os.path.exists(sourcesref):
364                                shutil.copy(sourcesref,self.origsourcesfile)
365                                if len(extrasources)>0: 
366                                        newsourcesedit=open(newsourcesfile,'a')
367                                        for line in extrasources:
368                                                newsourcesedit.write(line+'\n')
369                                        newsourcesedit.close()
370                        else:
371                                os.rename(self.origsourcesfileback,self.origsourcesfile)                                       
[7449]372       
373        #def addSourcesListLliurex             
[3449]374
375        def restoreOrigSourcesList(self):
376               
377                if os.path.exists(self.origsourcesfileback):
378                        os.rename(self.origsourcesfileback,self.origsourcesfile)
379
[7449]380        #def restoreOrigSourcesList             
381
[3690]382        def readSourcesList(self):
383               
384                count=0
385                if os.path.exists(self.origsourcesfile):
386                        sources=open(self.origsourcesfile,'r')
387                        ref="/lliurex.net/"+str(self.defaultVersion)
388                        for line in sources:
389                                if ref in line:
390                                        if not "#" in line:
391                                                count=count+1
[7449]392                return count   
[3449]393
[7449]394        #def readSourcesList           
395
[3254]396        def cleanEnvironment(self):
[3735]397               
[3254]398                if os.path.exists(self.processPath):
399                        shutil.rmtree(os.path.join(self.processPath))
400
[3449]401                self.restoreOrigSourcesList()   
[3254]402
[7449]403        #def cleanEnvironment   
404
[3690]405        def cleanLliurexUpLock(self):
[3449]406
[3690]407                if os.path.exists(self.lockTokenPath):
408                        os.remove(self.lockTokenPath)
409
[7449]410        #def cleanLliurexUpLock         
411
[3254]412        def updateCacheApt(self,options=""):
[3735]413               
[3390]414                command = "LANG=C LANGUAGE=en apt-get update {options}".format(options=options)
[3254]415                subprocess.Popen(command,shell=True).communicate()
416
[7449]417        #def updateCacheApt     
[3254]418
[7449]419
[3254]420        def getPackageVersionAvailable(self,package,options=""):
421                '''
422                        Args :
423                                package String
424                                options String
425
426                        return dictionary => result
427                        result : {'installed':String,'candidate':String}
428
429                        Options are Apt options
430                '''
[3390]431                command = "LANG=C LANGUAGE=en apt-cache policy {package} {options}".format(package=package,options=options)
[3254]432                p = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
433                installed = None
434                candidate = None
435                for line in iter(p.stdout.readline,""):
436                        stripedline = line.strip()
437                        if stripedline.startswith("Installed"):
438                                installed = stripedline.replace("Installed: ","")
439                        if stripedline.startswith("Candidate"):
440                                candidate = stripedline.replace("Candidate: ","")
441                return {"installed":installed,"candidate":candidate}
442
[7449]443        #def getPackageVersionAvailable
444
[4753]445        def isLliurexUpIsUpdated(self,args=None):
[3254]446                '''
447                        return Boolean
448                '''
449                sourceslistDefaultPath = os.path.join(self.processSourceslist,'default')
[3690]450
451                if "client" in self.previousFlavours or "lliurex-meta-client"==self.targetMetapackage:
[4753]452                        if not args:
453                                sources=self.readSourcesList()
454                                if sources==0:
455                                        sourceslistDefaultPath = os.path.join(self.processSourceslist,'default_mirror')
[3690]456
457
[3254]458                options = ""
459                if self.canConnectToLliurexNet():
[3532]460                        options = "-o Dir::Etc::sourcelist={sourceslistOnlyLliurex} -o Dir::Etc::sourceparts=/dev/null".format(sourceslistOnlyLliurex=sourceslistDefaultPath)
[3449]461
[3254]462                self.updateCacheApt(options)
463                result = self.getPackageVersionAvailable('lliurex-up',options)
464
465                if result['installed'] != result['candidate']:
466                        return False
467                return True
468
[7449]469        #def isLliurexUpIsUpdated       
470
[3254]471        def installLliurexUp(self,options=""):
472                '''
473                        Args :
474                                options String
475                        return dictionary => result
476                        result : {'returncode':Int,'stdout':String,'stderr':String}
477
478                        options are Apt options
479                       
480
481                        This function install lliurex-up
482                '''
[3690]483                self.updateCacheApt(options)
[4093]484                command = "LANG=C LANGUAGE=en DEBIAN_FRONTEND=noninteractive apt-get install --allow-downgrades --allow-remove-essential --allow-change-held-packages --yes lliurex-up {options}".format(options=options)
[3254]485                p = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
486                poutput,perror = p.communicate()
487                return {'returncode':p.returncode,'stdout':poutput,'stderrs':perror}
488
[7449]489        #def installLliurexUp   
490
[3254]491        def lliurexMirrorIsUpdated(self):
492                '''
493                        return None | dictionary => result
494                        result : {'status':Boolean,'msg':String,'action':String}
495                        result.msg : message of status
496                        result.action : Action to launch
497                '''
[3514]498                if self.haveLliurexMirror and ('server' in self.flavours or 'lliurex-meta-server'==self.targetMetapackage):
[3254]499                        result = self.n4d.is_update_available('','MirrorManager',self.defaultMirror)
500                        return result
501                return None
502
[7449]503        #def lliurexMirrorIsUpdated     
504
[3254]505        def lliurexMirrorIsRunning(self):
506                '''
507                        return Boolean
508                '''
[3514]509                if self.haveLliurexMirror and ('server' in self.flavours or 'lliurex-meta-server'==self.targetMetapackage):
[3254]510                        result = self.n4d.is_alive('','MirrorManager')
511                        return result['status']
512                return False
513
[7449]514        #def lliurexMirrorIsRunning     
515
[3690]516        def clientCheckingMirrorIsRunning(self):
517
518                if self.targetMetapackage=="lliurex-meta-client" or "client" in self.previousFlavours or "client" in self.metapackageRef:
[3693]519                       
520                        try:
521                                client=xmlrpclib.ServerProxy('https://server:9779')
522                                result=client.is_alive('','MirrorManager')
523                                return {'ismirrorrunning':result['status'],'exception':False}
524                       
525                        except Exception as e:
[3703]526                                return {'ismirrorrunning':None,'exception':str(e)}     
[3690]527
[3703]528                return {'ismirrorrunning':False,'exception':False}     
[3690]529
[7449]530        #def clientCheckingMirrorIsRunning     
531
[3254]532        def getPercentageLliurexMirror(self):
533                '''
534                        return int | None
535                '''
[3514]536                if self.haveLliurexMirror and ('server' in self.flavours or 'lliurex-meta-server'==self.targetMetapackage):
[3254]537                        result = self.n4d.get_percentage('','MirrorManager',self.defaultMirror)
538                        if result['status']:
539                                return result['msg']
540                return None
[7449]541
542        #def getPercentageLliurexMirror
[3254]543       
544        def checkFlavour(self):
545                '''
546                        return None|String
547                        If metapackages has been uninstalled, this function return
548                        package to must install. If return None, you are ok and don't need
549                        install anything.
550                '''
551                self.updateFlavoursList()
552                targetMetapackage = None
553                if 'None' in self.flavours:
554                        # get last flavour
[4563]555                        #result = self.n4d.lliurex_version('','LliurexVersion','--history')
556                        cmd='lliurex-version --history'
557                        p=subprocess.Popen(cmd,shell=True, stdout=subprocess.PIPE)
558                        result=p.communicate()
[3254]559                        if result[0]:
[4563]560                                #history = [ x.strip().split('\t')[0].strip() for x in result[1].split('\n') ]
561                                history = [ x.strip().split('\t')[0].strip() for x in result[0].split('\n') ]
[3254]562                                history = [ x for x in history if not 'lliurex-meta-live' in x ]
563                                for x in reversed(history):
564                                        if x.startswith('-'):
565                                                targetMetapackage = x[2:]
566                                                break
567
568                if targetMetapackage !=None:
569                        self.saveTargetMetapackage(targetMetapackage)                           
570                return targetMetapackage
571
[7449]572        #def checkFlavour       
573
[3254]574        def canConnectToLliurexNet(self):
575                '''
576                        return Boolean
577                '''
[4506]578                '''
579                s =  socket.socket(socket.AF_INET, socket.SOCK_STREAM)
580                host = socket.gethostbyname('lliurex.net')
581                result = s.connect_ex((host, 80))
582                s.close()
583                if result:
584                        return False
585                return True
586                '''
[3525]587                try:
588                        req=urllib2.Request("http://lliurex.net/xenial")
589                        res=urllib2.urlopen(req)
590                        return True
591                except:
[3254]592                        return False
[7449]593
594        #def canConnectToLliurexNet             
[3525]595                               
[3254]596        def getLliurexVersionLliurexNet(self):
597                '''
598                        return dictionary => result
599                        result : {'installed':String,'candidate':String}
600                '''
601                sourceslistDefaultPath = os.path.join(self.processSourceslist,'default')
602                options = ""
603                if self.canConnectToLliurexNet():
[3532]604                        options = "-o Dir::Etc::sourcelist={sourceslistOnlyLliurex} -o Dir::Etc::sourceparts=/dev/null".format(sourceslistOnlyLliurex=sourceslistDefaultPath)
[3254]605                self.updateCacheApt(options)
606                return self.getPackageVersionAvailable('lliurex-version-timestamp',options)
607
[7449]608        #def getLliurexVersionLliurexNet       
609       
[3254]610        def getLliurexVersionLocal(self):
[3735]611               
[3254]612                self.updateCacheApt('')
613                return self.getPackageVersionAvailable('lliurex-version-timestamp','')         
614
[7449]615        #def getLliurexVersionLocal
616
[3449]617        def initActionsScript(self,arg):
[3735]618               
[3449]619                #return 'run-parts --arg="initActions" ' + self.initActionsPath
620                return 'run-parts --arg=' +str(arg) + ' ' + self.initActionsPath
[3254]621
[7449]622        #def initActionsScript
[3449]623
[3254]624        def preActionsScript(self):
[3735]625               
[3254]626                return 'run-parts --arg="preActions" ' + self.preActionsPath
627
[7449]628        #def preActionsScript
629
[3254]630        def postActionsScript(self):
[3735]631               
[3254]632                return 'run-parts --arg="postActions" ' + self.postActionsPath
633
[4506]634        '''     
[7449]635        #def postActionsScript
636
[4506]637        def requiresInstallFlavour(self):
[3449]638               
[4506]639                flavourToInstall=None
[3449]640               
[4506]641                if not 'None' in self.previuosFlavours:
642                        if self.previuosFlavours !=self.flavours:
643                                flavourToInstall=self.parseFlavourToInstall(self.previousFlavours)
[3449]644                                                                               
[4506]645                else:
[3449]646                       
[4506]647                        if self.metapackageRef != self.flavours:
648                                flavourToInstall=self.parseFlavourToInstall(self.metapackageRef)
[3449]649                                                       
650
[4506]651                return flavourToInstall                                 
[3449]652
653               
[4506]654        def parseFlavourToInstall(self,flavours):
[3449]655       
[4506]656                parse_flavour=""
[3449]657
[4506]658                for item in flavours:
659                        if item != "edu":
660                                parse_flavour=parse_flavour + " " + "lliurex-meta-" + item
[3449]661
[4506]662                return parse_flavour
[3449]663                       
[4506]664        #def parseFlavourToInstall
665        '''
[3449]666
[3254]667        def installInitialFlavour(self,flavourToInstall,options=""):
668                '''
669                        Args :
670                                flavourToInstall String
671                                options String
672                        return dictionary => result
673                        result : {'returncode':Int,'stdout':String,'stderr':String}
674
675                        options are Apt options
676                       
677
678                        This function install lliurex-up
679                '''
[3735]680                self.updateCacheApt(options)
[4093]681                command = "LANG=C LANGUAGE=en DEBIAN_FRONTEND=noninteractive apt-get install --yes --allow-downgrades --allow-remove-essential --allow-change-held-packages " + flavourToInstall + "{options} ".format(options=options)
[3254]682                p = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
683                poutput,perror = p.communicate()
[4069]684               
685                if p.returncode!=0:
[4093]686                        command = "LANG=C LANGUAGE=en DEBIAN_FRONTEND=noninteractive apt-get install -f --yes --allow-downgrades --allow-remove-essential --allow-change-held-packages {options} ".format(options=options)
687                        p = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
[4069]688                        poutput,perror = p.communicate()
689
690
[3254]691                return {'returncode':p.returncode,'stdout':poutput,'stderrs':perror}   
692
[7449]693        #def installInitialFlavour
694
[3254]695        def getPackagesToUpdate(self):
696                '''
697                        packageInfo definition
698                        {
699                                'PACKAGENAME' : {
700                                                'install' : 'INSTALLEDVERSION',
701                                                'candidate' : 'CANDIDATEVERSION',
702                                                'icon' : 'ICONNAME',
703                                                'changelog' : 'CHANGELOGTEXT'
704                                }
705                        }
706                '''
[3449]707                self.packageInfo = {}
[3254]708                self.updateCacheApt("")
[3390]709                psimulate = subprocess.Popen('LANG=C LANGUAGE=en apt-get dist-upgrade -sV',shell=True,stdout=subprocess.PIPE)
[3254]710                rawoutputpsimulate = psimulate.stdout.readlines()
711                rawpackagestoinstall = [ aux.strip() for aux in rawoutputpsimulate if aux.startswith('Inst') ]
712                r = [ aux.replace('Inst ','') for aux in rawpackagestoinstall ]
713                for allinfo in r :
[3449]714                        self.packageInfo[allinfo.split(' ')[0]] = {}
715                        self.packageInfo[allinfo.split(' ')[0]]['raw'] = ' '.join(allinfo.split(' ')[1:])
[3254]716
[3449]717                for package in self.packageInfo:
718                        raw = self.packageInfo[package]['raw'].split(' ')
[3254]719                        if raw[0].startswith('['):
[3449]720                                self.packageInfo[package]['install'] = raw[0][1:-1]
721                                self.packageInfo[package]['candidate'] = raw[1][1:]
[3254]722                        elif raw[0].startswith('('):
[3449]723                                self.packageInfo[package]['install'] = None
724                                self.packageInfo[package]['candidate'] = raw[0][1:]
725                        self.packageInfo[package].pop('raw')
[3255]726                        #packageInfo[package]['changelog'] = os.path.join(self.changelogsPath,package)
[3390]727                        #os.system('LANG=C LANGUAGE=en apt-get changelog %s > %s%s'%(package,self.changelogsPath,package))
[3255]728                        #packageInfo[package]['icon'] =
[3449]729                return self.packageInfo
[3254]730
[7449]731        #def getPackagesToUpdate
732               
[3449]733        def checkIncorrectFlavours(self):
734               
735                self.incorrect_flavours=[]
736                count=0
737
738                for item in self.packageInfo:
[3514]739                        if item in self.flavourReference:
[3449]740                                self.incorrect_flavours.append(item)
741
742
743                if len(self.incorrect_flavours)>0:
744
745                        for item in self.incorrect_flavours:
746                                if self.targetMetapackage != None:
747                                        if item != self.targetMetapackage:
748                                                count=count+1
749                                else:
750                                        meta=item.split("-")[2]
[3542]751                                        if 'None' in self.previousFlavours:
[3449]752                                                if not meta in self.metapackageRef:
753                                                        count=count+1
754                                        else:           
[3542]755                                                if not meta in self.previousFlavours:
[3449]756                                                        count=count+1
757
758                if count>0:
759                        return True
760
761                else:
762                        return False   
763
[7449]764        #def checkIncorrectFlavours
[3449]765
[3254]766        def distUpgradeProcess(self):
767       
[4093]768                return 'apt-get dist-upgrade --yes --allow-downgrades --allow-remove-essential --allow-change-held-packages'
[3254]769
[7449]770        #def distUpgradeProcess
[3254]771
[3449]772        def checkErrorDistUpgrade(self):
773
[4072]774                countPostaction=0
775                countMetapackage=0
[3449]776                error=False
777
778                if os.path.exists(self.errorpostaction_token):
779                        aux = open(self.errorpostaction_token,'r')
780                        lines = aux.readlines()
781                        for x in lines:
782                                if 'E: ' in x:
[4072]783                                        countPostaction=countPostaction+1
[3449]784                        aux.close()
785
[4072]786                if countPostaction==0:
787
[4093]788                        if os.path.exists(self.errorfinalmetapackage_token):
789                                aux = open(self.errorfinalmetapackage_token,'r')
[3449]790                                lines = aux.readlines()
[4072]791                                for x in lines:
792                                        if 'E: ' in x:
793                                                countMetapackage=countMetapackage+1
[3449]794                                aux.close()
[4072]795                        if countMetapackage==0:
796                               
797                                cmd='dpkg -l | grep "^i[^i]" >' + self.errorupgrade_token
798                                os.system(cmd)
[3449]799                       
[4072]800                                if os.path.exists(self.errorupgrade_token):
801                                        aux = open(self.errorupgrade_token,'r')
802                                        lines = aux.readlines()
803                                        aux.close()
804                               
805                                        if len(lines)>0:
806                                                error=True
807                                                #log_msg="Dist-upgrade process ending with errors"
808                                                #self.log(log_msg)
809                                        else:
810                                                j=0
811                                                cmd='apt-get dist-upgrade -sV >' + self.finalupgrade_token
812                                                os.system(cmd)
813                                                if os.path.exists(self.finalupgrade_token):
814                                                        aux = open(self.finalupgrade_token,'r')
815                                                        lines = aux.readlines()
816                                                        aux.close()
[3449]817
[4072]818                                                        for x in lines:
819                                                                if 'Inst' in x:
820                                                                        j=j+1
[3449]821
[4072]822                                                        if j>0:
823                                                                error=True     
824                        else:
825                                error=True                                     
[3449]826                else:
827                        error=True
828
829                return error   
830
[7449]831        #def checkErrorDistUpgrade     
832
[4506]833        '''     
[3449]834        def checkFinalFlavour(self):
835               
836                flavourToInstall=None
837               
838                self.targetMetapackage=self.checkFlavour()
[3514]839                if self.targetMetapackage!=None:
840                        #flavourToInstall=self.requiresInstallFlavour()
841                #else:
[3449]842                        flavourToInstall=self.targetMetapackage         
843
[4506]844                return flavourToInstall
845        '''             
[3449]846
847
[3254]848        def installFinalFlavour(self,flavourToInstall):
849
[4093]850                return 'apt-get install ' + flavourToInstall + ' --yes  --allow-downgrades --allow-remove-essential --allow-change-held-packages'               
[3254]851       
[7449]852        #def installFinalFlavour
[3254]853
[7449]854        def get_process_list(self):
855               
856                self.process_list=[]
857               
858                p=subprocess.Popen(["ps","aux"],stdout=subprocess.PIPE,stderr=subprocess.PIPE)
859                output=p.communicate()[0]
860                lst=output.split("\n")
861                lst.pop(0)
862               
863                for item in lst:
864                        processed_line=item.split(" ")
865                        tmp_list=[]
866                       
867                        if len(processed_line) >= 10:
868                                for object in processed_line:
869                                        if object!="":
870                                                tmp_list.append(object)
871                                processed_line=tmp_list
872                               
873                                process={}
874                                process["user"]=processed_line[0]
875                                process["pid"]=processed_line[1]
876                                process["cpu"]=processed_line[2]
877                                process["mem"]=processed_line[3]
878                                process["vsz"]=processed_line[4]
879                                process["rss"]=processed_line[5]
880                                process["tty"]=processed_line[6]
881                                process["stat"]=processed_line[7]
882                                process["start"]=processed_line[8]
883                                process["time"]=processed_line[9]
884                                cmd=""
885                                for line in processed_line[10:]:
886                                        if cmd!="":
887                                                cmd+=" "
888                                        cmd+=line
889                                       
890                                process["command"]=cmd.split(" ")[0]
891                                self.process_list.append(process)
892
893        #def get_process_list                   
894
895        def find_process(self,filter):
896               
897                self.get_process_list()
898                ret_list=[]
899                for process in self.process_list:
900                        if filter in process["command"]:
901                                ret_list.append(process)
902                               
903                               
904                if len(ret_list)>0:
905                        return ret_list
906                else:
907                        return None
908
909        #def find_process               
910                               
911
912#def LliurexUpCore
[3254]913if __name__ == '__main__':
[3255]914        x = LliurexUpCore()
Note: See TracBrowser for help on using the repository browser.