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, 17 months ago

Wip in integration with dpkg-unlocker

File size: 25.0 KB
Line 
1import xmlrpclib 
2import os
3import shutil
4import subprocess
5import socket
6import distutils.dir_util
7import urllib2
8import time
9import psutil
10import struct, fcntl
11
12
13class LliurexUpCore(object):
14        """docstring for LliurexUpCore"""
15        def __init__(self):
16                super(LliurexUpCore, self).__init__()
17                self.flavourReference=["lliurex-meta-server","lliurex-meta-client", "lliurex-meta-desktop", "lliurex-meta-music", "lliurex-meta-pyme", "lliurex-meta-infantil"] 
18                self.defaultMirror = 'llx16'
19                self.defaultVersion = 'xenial'
20                self.lockTokenPath="/var/run/lliurexUp.lock"
21                self.processPath = '/var/run/lliurex-up'
22                self.sourcesListPath='/etc/apt/'
23                self.changelogsPath = os.path.join(self.processPath,'changelogs')
24                self.processSourceslist = os.path.join(self.processPath,'sourceslist')
25                self.origsourcesfile=os.path.join(self.sourcesListPath,"sources.list")
26                self.origsourcesfileback=os.path.join(self.sourcesListPath,"lliurexup_sources.list")
27                self.targetMetapackagePath=os.path.join(self.processPath,"targetMetapackage")
28                self.previousflavourspath = os.path.join(self.processPath,'previousflavours')
29                self.errorpostaction_token=os.path.join(self.processPath,'errorpostaction_token')
30                self.errorfinalmetapackage_token=os.path.join(self.processPath,'errorfinalmetapackage_token')
31                self.errorupgrade_token=os.path.join(self.processPath,'errorupgrade_token')
32                self.finalupgrade_token=os.path.join(self.processPath,'finalupgrade_token')
33
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
38        #def __init__   
39
40        def startLliurexUp(self):
41
42                self.createLockToken()
43                self.retryN4d=True
44                self.n4dStatus=True
45                self.n4d = xmlrpclib.ServerProxy('https://localhost:9779')
46                self.checkN4dStatus()
47                self.haveLliurexMirror = False
48                self.metapackageRef=[]
49                self.previousFlavours = []
50
51               
52                self.getTargetMetapackage()
53                self.flavours = []
54                self.getPreviousFlavours()
55               
56                if self.n4dStatus:
57                        if len(self.n4d.get_methods('MirrorManager')) > 0:
58                                self.haveLliurexMirror = True
59                       
60                self.retryN4d=True
61                self.prepareEnvironment()
62
63        #def startLliurexUp     
64
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
155        def createLockToken(self):
156
157                if not os.path.exists(self.lockTokenPath):
158                        f=open(self.lockTokenPath,'w')
159                        up_pid=os.getpid()
160                        f.write(str(up_pid))
161                        f.close()
162
163        #def createLockToken           
164
165        def getPreviousFlavours(self):
166               
167                if os.path.exists(self.previousflavourspath):
168                        aux = open(self.previousflavourspath,'r')
169                        lines = aux.readlines()
170                        for x in lines:
171                                self.previousFlavours.append(x.strip())
172                        aux.close()
173
174        #def getPreviousFlavours               
175
176        def checkN4dStatus(self):
177       
178                checkStatus=True
179                cmd='systemctl status n4d.service 1>/dev/null'
180                result=os.system(cmd)
181
182                if result !=0:
183                        if self.retryN4d:
184                                self.retryN4d=False
185                                try: 
186                                        cmd='systemctl restart n4d.service 1>/dev/null'
187                                        restart=os.system(cmd)
188                                        time.sleep(5)
189                                        if restart ==0:
190                                                self.checkN4dStatus()
191                                        else:
192                                                self.n4dStatus=False
193                                                                                               
194                                except Exception as e:
195                                        self.n4dStatus=False
196                                       
197                                       
198                        else:
199                                self.n4dStatus=False
200                               
201                                                                               
202                else:           
203                        self.n4dStatus=True
204
205        #def checkN4dStatus             
206                       
207                               
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
217        #def getTargetMetapackage
218                       
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()
227
228        #def saveTargetMetapackage     
229
230        def checkInitialFlavour(self,args=None):
231
232                self.targetMetapackage=self.checkFlavour()
233                if len(self.metapackageRef)==0:
234                        self.getTargetMetapackage()
235               
236                self.metapackageRef=sorted(self.metapackageRef) 
237                         
238                if len(self.previousFlavours)==0:
239                        self.getPreviousFlavours()
240               
241
242                self.writeDefaultSourceslist()
243                self.writeDefaultSourceslistMirror()
244                self.writeDefaultSourceslistAll()
245
246                self.addSourcesListLliurex(args)
247
248                return self.targetMetapackage
249
250        #def checkInitialFlavour       
251               
252        def updateFlavoursList(self):
253               
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
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
266        #def updateFlavoursList         
267
268        def writeDefaultSourceslist(self):
269
270                f = open(os.path.join(self.processSourceslist,'default'),'w')
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))
274                f.close()
275
276        #def writeDefaultSourceslist   
277
278        def writeDefaultSourceslistMirror(self):
279               
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
286        #def writeDefaultSourceslistMirror     
287
288
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))
298                f.close()       
299
300        #def writeDefaultSourceslistAll         
301
302        def prepareEnvironment(self):
303                '''
304                        This funcion delete all environment and rebuild environment
305
306                '''
307                self.cleanEnvironment()
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)
314
315                #self.writeDefaultSourceslist()
316                #self.writeDefaultSourceslistMirror()
317
318        #def prepareEnvironment
319
320        def addSourcesListLliurex(self,args=None):
321               
322                #sourcesrefmirror=os.path.join(self.processSourceslist, 'default_mirror')
323
324                newsourcesfile=os.path.join(self.sourcesListPath,'sources.list')
325                extrasources=[]
326                client=False
327                textsearch_mirror="/mirror/"+str(self.defaultMirror)
328                textsearch_lliurex="/lliurex.net/"+str(self.defaultVersion)
329
330
331                if self.targetMetapackage=="lliurex-meta-client" or "client" in self.previousFlavours or "client" in self.metapackageRef:
332                        client=True
333                        if args:
334                                sourcesref=os.path.join(self.processSourceslist, 'default_all')
335
336                        else:
337                                #textsearch="/mirror/"+str(self.defaultMirror)
338                                sourcesref=os.path.join(self.processSourceslist, 'default_mirror')
339
340                else:
341                        #textsearch="/lliurex.net/"+str(self.defaultVersion)
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')
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
361                        origsources.close()
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)                                       
372       
373        #def addSourcesListLliurex             
374
375        def restoreOrigSourcesList(self):
376               
377                if os.path.exists(self.origsourcesfileback):
378                        os.rename(self.origsourcesfileback,self.origsourcesfile)
379
380        #def restoreOrigSourcesList             
381
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
392                return count   
393
394        #def readSourcesList           
395
396        def cleanEnvironment(self):
397               
398                if os.path.exists(self.processPath):
399                        shutil.rmtree(os.path.join(self.processPath))
400
401                self.restoreOrigSourcesList()   
402
403        #def cleanEnvironment   
404
405        def cleanLliurexUpLock(self):
406
407                if os.path.exists(self.lockTokenPath):
408                        os.remove(self.lockTokenPath)
409
410        #def cleanLliurexUpLock         
411
412        def updateCacheApt(self,options=""):
413               
414                command = "LANG=C LANGUAGE=en apt-get update {options}".format(options=options)
415                subprocess.Popen(command,shell=True).communicate()
416
417        #def updateCacheApt     
418
419
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                '''
431                command = "LANG=C LANGUAGE=en apt-cache policy {package} {options}".format(package=package,options=options)
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
443        #def getPackageVersionAvailable
444
445        def isLliurexUpIsUpdated(self,args=None):
446                '''
447                        return Boolean
448                '''
449                sourceslistDefaultPath = os.path.join(self.processSourceslist,'default')
450
451                if "client" in self.previousFlavours or "lliurex-meta-client"==self.targetMetapackage:
452                        if not args:
453                                sources=self.readSourcesList()
454                                if sources==0:
455                                        sourceslistDefaultPath = os.path.join(self.processSourceslist,'default_mirror')
456
457
458                options = ""
459                if self.canConnectToLliurexNet():
460                        options = "-o Dir::Etc::sourcelist={sourceslistOnlyLliurex} -o Dir::Etc::sourceparts=/dev/null".format(sourceslistOnlyLliurex=sourceslistDefaultPath)
461
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
469        #def isLliurexUpIsUpdated       
470
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                '''
483                self.updateCacheApt(options)
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)
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
489        #def installLliurexUp   
490
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                '''
498                if self.haveLliurexMirror and ('server' in self.flavours or 'lliurex-meta-server'==self.targetMetapackage):
499                        result = self.n4d.is_update_available('','MirrorManager',self.defaultMirror)
500                        return result
501                return None
502
503        #def lliurexMirrorIsUpdated     
504
505        def lliurexMirrorIsRunning(self):
506                '''
507                        return Boolean
508                '''
509                if self.haveLliurexMirror and ('server' in self.flavours or 'lliurex-meta-server'==self.targetMetapackage):
510                        result = self.n4d.is_alive('','MirrorManager')
511                        return result['status']
512                return False
513
514        #def lliurexMirrorIsRunning     
515
516        def clientCheckingMirrorIsRunning(self):
517
518                if self.targetMetapackage=="lliurex-meta-client" or "client" in self.previousFlavours or "client" in self.metapackageRef:
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:
526                                return {'ismirrorrunning':None,'exception':str(e)}     
527
528                return {'ismirrorrunning':False,'exception':False}     
529
530        #def clientCheckingMirrorIsRunning     
531
532        def getPercentageLliurexMirror(self):
533                '''
534                        return int | None
535                '''
536                if self.haveLliurexMirror and ('server' in self.flavours or 'lliurex-meta-server'==self.targetMetapackage):
537                        result = self.n4d.get_percentage('','MirrorManager',self.defaultMirror)
538                        if result['status']:
539                                return result['msg']
540                return None
541
542        #def getPercentageLliurexMirror
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
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()
559                        if result[0]:
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') ]
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
572        #def checkFlavour       
573
574        def canConnectToLliurexNet(self):
575                '''
576                        return Boolean
577                '''
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                '''
587                try:
588                        req=urllib2.Request("http://lliurex.net/xenial")
589                        res=urllib2.urlopen(req)
590                        return True
591                except:
592                        return False
593
594        #def canConnectToLliurexNet             
595                               
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():
604                        options = "-o Dir::Etc::sourcelist={sourceslistOnlyLliurex} -o Dir::Etc::sourceparts=/dev/null".format(sourceslistOnlyLliurex=sourceslistDefaultPath)
605                self.updateCacheApt(options)
606                return self.getPackageVersionAvailable('lliurex-version-timestamp',options)
607
608        #def getLliurexVersionLliurexNet       
609       
610        def getLliurexVersionLocal(self):
611               
612                self.updateCacheApt('')
613                return self.getPackageVersionAvailable('lliurex-version-timestamp','')         
614
615        #def getLliurexVersionLocal
616
617        def initActionsScript(self,arg):
618               
619                #return 'run-parts --arg="initActions" ' + self.initActionsPath
620                return 'run-parts --arg=' +str(arg) + ' ' + self.initActionsPath
621
622        #def initActionsScript
623
624        def preActionsScript(self):
625               
626                return 'run-parts --arg="preActions" ' + self.preActionsPath
627
628        #def preActionsScript
629
630        def postActionsScript(self):
631               
632                return 'run-parts --arg="postActions" ' + self.postActionsPath
633
634        '''     
635        #def postActionsScript
636
637        def requiresInstallFlavour(self):
638               
639                flavourToInstall=None
640               
641                if not 'None' in self.previuosFlavours:
642                        if self.previuosFlavours !=self.flavours:
643                                flavourToInstall=self.parseFlavourToInstall(self.previousFlavours)
644                                                                               
645                else:
646                       
647                        if self.metapackageRef != self.flavours:
648                                flavourToInstall=self.parseFlavourToInstall(self.metapackageRef)
649                                                       
650
651                return flavourToInstall                                 
652
653               
654        def parseFlavourToInstall(self,flavours):
655       
656                parse_flavour=""
657
658                for item in flavours:
659                        if item != "edu":
660                                parse_flavour=parse_flavour + " " + "lliurex-meta-" + item
661
662                return parse_flavour
663                       
664        #def parseFlavourToInstall
665        '''
666
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                '''
680                self.updateCacheApt(options)
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)
682                p = subprocess.Popen(command,shell=True,stdout=subprocess.PIPE)
683                poutput,perror = p.communicate()
684               
685                if p.returncode!=0:
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)
688                        poutput,perror = p.communicate()
689
690
691                return {'returncode':p.returncode,'stdout':poutput,'stderrs':perror}   
692
693        #def installInitialFlavour
694
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                '''
707                self.packageInfo = {}
708                self.updateCacheApt("")
709                psimulate = subprocess.Popen('LANG=C LANGUAGE=en apt-get dist-upgrade -sV',shell=True,stdout=subprocess.PIPE)
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 :
714                        self.packageInfo[allinfo.split(' ')[0]] = {}
715                        self.packageInfo[allinfo.split(' ')[0]]['raw'] = ' '.join(allinfo.split(' ')[1:])
716
717                for package in self.packageInfo:
718                        raw = self.packageInfo[package]['raw'].split(' ')
719                        if raw[0].startswith('['):
720                                self.packageInfo[package]['install'] = raw[0][1:-1]
721                                self.packageInfo[package]['candidate'] = raw[1][1:]
722                        elif raw[0].startswith('('):
723                                self.packageInfo[package]['install'] = None
724                                self.packageInfo[package]['candidate'] = raw[0][1:]
725                        self.packageInfo[package].pop('raw')
726                        #packageInfo[package]['changelog'] = os.path.join(self.changelogsPath,package)
727                        #os.system('LANG=C LANGUAGE=en apt-get changelog %s > %s%s'%(package,self.changelogsPath,package))
728                        #packageInfo[package]['icon'] =
729                return self.packageInfo
730
731        #def getPackagesToUpdate
732               
733        def checkIncorrectFlavours(self):
734               
735                self.incorrect_flavours=[]
736                count=0
737
738                for item in self.packageInfo:
739                        if item in self.flavourReference:
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]
751                                        if 'None' in self.previousFlavours:
752                                                if not meta in self.metapackageRef:
753                                                        count=count+1
754                                        else:           
755                                                if not meta in self.previousFlavours:
756                                                        count=count+1
757
758                if count>0:
759                        return True
760
761                else:
762                        return False   
763
764        #def checkIncorrectFlavours
765
766        def distUpgradeProcess(self):
767       
768                return 'apt-get dist-upgrade --yes --allow-downgrades --allow-remove-essential --allow-change-held-packages'
769
770        #def distUpgradeProcess
771
772        def checkErrorDistUpgrade(self):
773
774                countPostaction=0
775                countMetapackage=0
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:
783                                        countPostaction=countPostaction+1
784                        aux.close()
785
786                if countPostaction==0:
787
788                        if os.path.exists(self.errorfinalmetapackage_token):
789                                aux = open(self.errorfinalmetapackage_token,'r')
790                                lines = aux.readlines()
791                                for x in lines:
792                                        if 'E: ' in x:
793                                                countMetapackage=countMetapackage+1
794                                aux.close()
795                        if countMetapackage==0:
796                               
797                                cmd='dpkg -l | grep "^i[^i]" >' + self.errorupgrade_token
798                                os.system(cmd)
799                       
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()
817
818                                                        for x in lines:
819                                                                if 'Inst' in x:
820                                                                        j=j+1
821
822                                                        if j>0:
823                                                                error=True     
824                        else:
825                                error=True                                     
826                else:
827                        error=True
828
829                return error   
830
831        #def checkErrorDistUpgrade     
832
833        '''     
834        def checkFinalFlavour(self):
835               
836                flavourToInstall=None
837               
838                self.targetMetapackage=self.checkFlavour()
839                if self.targetMetapackage!=None:
840                        #flavourToInstall=self.requiresInstallFlavour()
841                #else:
842                        flavourToInstall=self.targetMetapackage         
843
844                return flavourToInstall
845        '''             
846
847
848        def installFinalFlavour(self,flavourToInstall):
849
850                return 'apt-get install ' + flavourToInstall + ' --yes  --allow-downgrades --allow-remove-essential --allow-change-held-packages'               
851       
852        #def installFinalFlavour
853
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
913if __name__ == '__main__':
914        x = LliurexUpCore()
Note: See TracBrowser for help on using the repository browser.