source: epi/trunk/fuentes/python3-epi/epimanager.py @ 8369

Last change on this file since 8369 was 8369, checked in by jrpelegrina, 7 weeks ago

Removed link with lliurex-store

File size: 15.1 KB
Line 
1#!/usr/bin/env python3
2
3import os
4import subprocess
5import sys
6import json
7import platform
8#import socket
9import tempfile
10import time
11import datetime
12import urllib.request
13
14#import lliurexstore.storeManager as StoreManager
15
16
17class EpiManager:
18       
19        def __init__(self):
20
21
22                #self.storeManager=StoreManager.StoreManager()
23                self.reposPath="/etc/apt/sources.list.d/"
24                self.sources_list="epi.list"
25                self.epi_sources=os.path.join(self.reposPath,self.sources_list)
26                self.epi_keyring="/tmp/epi_keyring"
27                                               
28                self.order=0
29                self.epiFiles={}
30                self.arquitecture=False
31                self.update=False
32                self.zomando_name={}
33                self.epi_base={"repository":[],
34                                        "force32" : False,
35                                        "required_x" : False,
36                                        "script": {},
37                                        "depends":"",
38                                        "zomando":"",
39                                        "required_root":False
40                                        }
41
42                #self.read_conf(epi_file)
43       
44               
45        #def __init__   
46
47       
48        def check_connection(self):
49       
50                result=[]
51                try:
52                        res=urllib.request.urlopen("http://lliurex.net")
53                        result.append(True)
54                       
55                except Exception as e:
56                        result.append(False)
57                        result.append(str(e))
58                       
59                return result   
60
61        #def check_connection   
62
63        def read_conf(self,epi_file):
64
65
66                if os.path.exists(epi_file):
67                        f=open(epi_file)
68                        try:
69                                epi_load=json.load(f)
70                                epi_conf=self.epi_base.copy()
71                                f.close()
72                                epi_conf.update(epi_load)
73                                self.epiFiles[self.order]=epi_conf
74                                self.zomando_name[self.order]=epi_conf["zomando"]
75                                try:
76                                        if epi_conf["depends"]!="":
77                                                self.order=self.order+1
78                                                self.read_conf(epi_conf["depends"])
79                                except :
80                                        pass
81                        except:
82                                return False
83
84                return True                     
85
86        #def read_conf         
87
88
89        def get_pkg_info(self):
90
91                pkg_list=[]
92                self.pkg_info={}
93                tmp_list=self.epiFiles.copy()
94
95                for item in tmp_list:
96                        pkg_list=[]
97                        pkg_list=tmp_list[item]["pkg_list"]
98                       
99                        info=self.get_store_info(pkg_list,item)
100
101                        cont=0
102
103                        for element in pkg_list:
104                                name=element["name"]
105                                if info[name]["status"]=="installed":
106                                        cont=cont+1
107
108                        if cont==len(pkg_list):
109                                if item>0:
110                                        self.epiFiles.pop(item)
111                                        self.zomando_name.pop(item)
112                                else:
113                                        self.epiFiles[item]["status"]="installed"
114                                        self.pkg_info.update(info)
115                        else:
116                                self.epiFiles[item]["status"]="availabled"
117                                self.pkg_info.update(info)     
118
119        #def get_pkg_info                               
120                                                       
121
122        def get_store_info(self,pkg_list,order):                       
123
124                        self.getStatus_byscript=False
125                        pkg_info={}
126                                               
127                        for item in pkg_list:
128                                app=item["name"]
129                                name=""
130                                summary=""
131                                status=""
132                                description=""
133                                icon=""
134                                debian_name=""
135                                component=""
136                                '''
137                                try:
138                                        pkg=item["key_store"]
139                                        action="info"
140                                        self.storeManager.execute_action(action,pkg)
141                                        while self.storeManager.is_action_running(action):
142                                                time.sleep(0.2)
143
144                                       
145                                        ret=self.storeManager.get_status(action)
146
147                                        if ret["status"]==0:
148                                                data=self.storeManager.get_result(action)
149
150                                                if len(data)>0:
151
152                                                        description=data["info"][0]["description"]
153                                                        icon=data["info"][0]["icon"]
154                                                        name=data["info"][0]["name"]
155                                                        summary=data["info"][0]["summary"]
156                                                        debian_name=data["info"][0]["package"]
157                                                        component=data["info"][0]["component"]
158
159                                                        status=self.check_pkg_status(app,order)
160                                                        if not self.getStatus_byscript and status!="installed":
161                                                                if (data["info"][0]["state"]) !="":
162                                                                        status=data["info"][0]["state"]
163
164                                                else:
165                                                        status=self.check_pkg_status(app,order)         
166                                        else:
167                                                status=self.check_pkg_status(app,order)
168                               
169                                except:
170                                        status=self.check_pkg_status(app,order)
171                                '''
172                                status=self.check_pkg_status(app,order)                 
173                               
174                                pkg_info[app]={}
175                                pkg_info[app]["debian_name"]=""
176                                pkg_info[app]["component"]=""
177                                pkg_info[app]["status"]=status
178                                pkg_info[app]["description"]=""
179                                pkg_info[app]["icon"]=""
180                                pkg_info[app]["name"]=""
181                                pkg_info[app]["summary"]=""
182
183                        return pkg_info
184
185        #def get_store_info                     
186
187        def check_pkg_status(self,pkg,order=None):
188       
189
190                try:
191                        if self.epiFiles[order]["script"]["getStatus"]:
192                                self.getStatus_byscript=True
193                except:
194                        pass
195
196                if self.getStatus_byscript:
197                        if order !=None:
198                                try:
199                                        script=self.epiFiles[order]["script"]["name"]
200                                        if os.path.exists(script):
201                                                cmd=script +' getStatus ' + pkg;
202                                                p=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
203                                                poutput=p.communicate()
204                                                if len(poutput)>0:
205                                                        if poutput[0].decode("utf-8").split("\n")[0]=='0':
206                                                                return "installed"
207                                               
208                                except Exception as e:
209                                        self.getStatus_byscript=False
210                                        #print (str(e))
211                                        pass
212                else:                                   
213
214                        cmd='dpkg -l '+ pkg + '| grep "^i[i]"'
215                        p=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
216                        poutput,perror=p.communicate()
217
218                        if len(poutput)>0:
219                                return "installed"
220               
221                               
222                return "available"     
223
224        #def check_pkg_status                                   
225               
226        def check_root(self):
227
228                self.root=False
229
230                try:
231                        f=open("/etc/epi.token","w")
232                        f.close()
233                        os.remove("/etc/epi.token")
234                        self.download_path="/var/cache/epi-downloads"
235                        self.root=True
236                except:
237                        if not os.path.exists(os.path.expanduser("~/.cache/epi-downloads/")):
238                                os.mkdir(os.path.expanduser("~/.cache/epi-downloads/"))
239                        self.download_path=os.path.expanduser("~/.cache/epi-downloads/")
240
241        #def check_root         
242
243
244        def required_root (self):
245
246                cont=0
247
248                if not self.root:
249                        for item in self.epiFiles:
250                                if self.epiFiles[item]["type"]!="file":
251                                        cont=cont+1
252
253                                else:
254                                        if self.epiFiles[item]["required_root"]:
255                                                cont=cont+1
256                                                       
257                        if cont>0:
258                                return True
259                        else:
260                                return False   
261
262                else:
263                        return False           
264
265        #def required_root             
266
267
268        def required_eula(self):
269
270                eulas=[]
271
272                for item in self.epiFiles:
273                        cont=0
274                        for pkg in self.epiFiles[item]["pkg_list"]:
275                                try:
276                                        if pkg["eula"]!="":
277                                                tmp={}
278                                                tmp["order"]=item
279                                                tmp["pkg_name"]=pkg["name"]
280                                                tmp["eula"]=pkg["eula"]
281                                                eulas.append(tmp)
282                                except:
283                                        pass           
284                                       
285                return eulas
286
287        #def required_eula     
288       
289        def check_update_repos(self):
290               
291                #Only update repos if needed
292                current_date=datetime.date.today().strftime('%y%m%d')
293                filename='/var/cache/apt/pkgcache.bin'
294                lastmod=os.path.getmtime(filename)
295                lastupdate=datetime.datetime.fromtimestamp(lastmod).strftime('%y%m%d')
296                cmd=""
297
298                if current_date !=lastupdate or self.update:
299                        cmd="LANG=C LANGUAGE=en apt-get update; "
300                else:
301                        for item in self.epi_conf["pkg_list"]:
302                                update_repo=False
303                                app=item["name"]
304                                command="LANG=C LANGUAGE=en apt-cache policy %s"%app
305                                p=subprocess.Popen(command,shell=True, stdout=subprocess.PIPE)
306                                output=p.communicate()
307                                if str(output[0]) != '':
308                                        tmp=str(output[0]).split("\\n")
309                                        if len(tmp)>1:
310                                                if tmp[2].split(":")[1]=="":
311                                                        update_repo=True
312                                                       
313                                        else:
314                                                update_repo=True
315                                               
316
317                                else:
318                                        update_repo=True
319
320                                if update_repo: 
321                                        cmd="LANG=C LANGUAGE=en apt-get update; "
322                                        return cmd             
323
324                return cmd
325               
326        #def check_update_repos
327
328        def check_arquitecture(self):
329
330                self.force32=self.epi_conf['force32']
331                cmd=""
332               
333                if self.force32:
334                        if platform.architecture()[0]=='64bit':
335                                cmd='dpkg --add-architecture i386; '
336                                self.update=True
337                                                               
338                self.arquitecture=True
339                return cmd             
340
341        #def check_arquitecture
342       
343        def add_repository_keys(self,order):
344
345                self.epi_conf=self.epiFiles[order]
346
347                cmd=""
348                self.type=self.epi_conf["type"]
349
350                if self.type=="apt":
351
352                        repos_list=self.epi_conf["repository"]
353
354                        if len(repos_list)>0:
355                                f = open(self.epi_sources,'w')
356                                for item in repos_list:
357                                        if item["url"]!="":
358                                                lines=item["url"].split(";")
359                                                for line in lines:
360                                                        f.write(line+'\n')
361                                        try:
362                                                key_cmd=item["key_cmd"]
363                                                if key_cmd !="":
364                                                        cmd=cmd+key_cmd+';'     
365                                        except Exception as e:
366                                                if len(self.epi_conf["script"])>0:
367                                                        try:
368                                                                if self.epi_conf["script"]["addRepoKeys"]:
369                                                                        script=self.epi_conf["script"]["name"]
370                                                                        if os.path.exists(script):
371                                                                                command=script + ' addRepoKeys;'
372                                                                                cmd=cmd+command
373                                                        except Exception as e:
374                                                                #print (str(e))
375                                                                pass
376
377                                f.close()
378                                self.update=True
379
380                       
381                return cmd             
382
383        #def add_repository_keys       
384
385
386        def get_app_version(self,item=None):
387
388                self.force32=self.epi_conf["force32"]
389
390                if self.force32:
391                        version=item["version"]["32b"]
392                       
393                else:
394                        try:
395                                version=item["version"]["all"]
396                        except Exception as e:
397                                if platform.architecture()[0]=='64bit': 
398                                        version=item["version"]["64b"]
399                                else:
400                                        version=item["version"]["32b"]
401                       
402                return version
403
404        #def get_app_version   
405                                               
406        def download_app(self):
407
408                self.manage_download=True
409                self.download_folder={}
410                cmd=""
411
412                self.type=self.epi_conf["type"]
413                if self.type !='apt':
414
415                        self.token_result_download=tempfile.mkstemp("_result_download")
416                       
417                        if self.type=="file":
418                                if len(self.epi_conf["script"])>0:
419                                        try:
420                                                if self.epi_conf["script"]["download"]:
421                                                        script=self.epi_conf["script"]["name"]
422                                                        if os.path.exists(script):
423                                                                cmd=script +' download; echo $? >' + self.token_result_download[1] +';'
424                                                                self.manage_download=False
425                                        except:
426                                                pass                   
427
428                        if self.manage_download:
429
430                                for item in self.epi_conf["pkg_list"]:
431                                        version=self.get_app_version(item)
432                                        if self.type=="deb":
433                                                name=item["name"]+".deb"
434                                                tmp_file=os.path.join(self.download_path,name)
435                                        elif self.type=="file":
436                                                try:
437                                                        tmp_file=os.path.join(self.download_path,item["alias_download"])
438                                                except Exception as e: 
439                                                        #name=item["name"]
440                                                        tmp_file=os.path.join(self.download_path,version)
441                               
442                                        url=item["url_download"]
443                                       
444                                        if os.path.exists(tmp_file):
445                                                cmd=cmd+'rm -f '+ tmp_file +';'
446                                        self.download_folder["name"]=tmp_file
447                                        cmd=cmd+'wget ' +url+version + ' --progress=bar:force --no-check-certificate -O ' + tmp_file +'; '
448
449                                cmd=cmd + ' echo $? >' + self.token_result_download[1] +';'     
450                       
451
452                return cmd                     
453                                       
454        #def download_app               
455
456
457        def check_download(self):
458
459               
460                result=True
461
462                if self.type !='apt':
463
464                       
465                        if os.path.exists(self.token_result_download[1]):
466                                file=open(self.token_result_download[1])
467                                content=file.readline()
468                                if '0' not in content:
469                                        result=False
470                                file.close()
471                                os.remove(self.token_result_download[1])
472
473                                if result:     
474                                        if self.manage_download:
475                                                pkgs_todownload=len(self.download_folder)
476                                                cont=0
477
478                                                for item in self.download_folder:
479                                                        if os.path.exists(self.download_folder[item]):
480                                                                cont=cont+1
481
482                                                if cont != pkgs_todownload:
483                                                        result=False
484
485                return result
486
487        #def check_download             
488
489        def preinstall_app(self):
490       
491
492                cmd=""
493
494                if len(self.epi_conf["script"])>0:
495                        self.token_result_preinstall=tempfile.mkstemp("_result_preinstall")
496                        script=self.epi_conf["script"]["name"]
497                        if os.path.exists(script):
498                                cmd=script +' preInstall; echo $? >' + self.token_result_preinstall[1] +';'
499
500                return cmd             
501
502        #def preinstall_app     
503       
504
505        def check_preinstall(self):
506               
507                result=True
508
509                try:
510                        if os.path.exists(self.token_result_preinstall[1]):
511                                file=open(self.token_result_preinstall[1])
512                                content=file.readline()
513                                if '0' not in content:
514                                        result=False
515                                file.close()
516                                os.remove(self.token_result_preinstall[1])
517
518                except:                 
519                        pass
520
521                return result
522
523
524        #def check_preinstall_app       
525
526        def install_app(self):
527       
528                add_i386=""
529               
530                if not self.arquitecture:
531                        add_i386=self.check_arquitecture()
532
533
534                cmd=""
535               
536                if self.type=="apt":
537
538                        update_repos=self.check_update_repos()
539                        cmd=add_i386+update_repos+"LANG=C LANGUAGE=en DEBIAN_FRONTEND=noninteractive apt-get install --reinstall --allow-downgrades --allow-remove-essential --allow-change-held-packages --yes "
540                        for item in self.epi_conf["pkg_list"]:
541                                app=item["name"]
542                                cmd=cmd + app +" "
543
544       
545                       
546                elif self.type=="deb":
547                       
548                        cmd="dpkg -i "
549                        for item in self.epi_conf["pkg_list"]:
550                                name=item["name"]+".deb"
551                                pkg=self.download_folder["name"]
552                                cmd=cmd+pkg +" "
553
554                       
555                elif self.type=="file":
556                        self.token_result_install=tempfile.mkstemp("_result")
557                        script=self.epi_conf["script"]["name"]
558                        if os.path.exists(script):
559                                cmd=script + ' installPackage; echo $? >' + self.token_result_install[1]
560
561                cmd=cmd+";"
562                return cmd     
563
564        #def install_app       
565
566
567        def check_install_remove(self,action):
568
569                dpkg_status={}
570                cont=0
571                token=""
572               
573                if action=="install":
574                               
575                        if self.type !="file":
576                                pkgs=self.epi_conf["pkg_list"]
577                       
578                                for item in pkgs:
579                                        status=self.check_pkg_status(item["name"])
580                               
581                                        if status=="installed":
582                                                cont=cont+1
583                               
584                                        dpkg_status[item["name"]]=status
585
586                                if cont==len(pkgs):
587                                        result=True
588               
589                                else:
590                                        result=False
591
592                        else:
593                                token=self.token_result_install[1]     
594                                if os.path.exists(token):
595                                        file=open(token)
596                                        content=file.readline()
597                                        if '0' not in content:
598                                                result=False
599                                        else:
600                                                result=True     
601                                                                               
602                                        file.close()
603                                        os.remove(token)
604
605                else:
606               
607                        if self.epiFiles[0]["type"] !="file":
608                                        pkgs=self.epiFiles[0]["pkg_list"]                       
609                                        for item in pkgs:
610                                                status=self.check_pkg_status(item["name"])
611                                                if status!="installed":
612                                                        cont=cont+1
613                                                dpkg_status[item["name"]]=status
614
615               
616                        token=self.token_result_remove[1]
617                        if os.path.exists(token):
618                                        file=open(token)
619                                        content=file.readline()
620                                        if '0' not in content:
621                                                result=False
622                                        else:
623                                                result=True     
624                                                       
625                                        file.close()
626                                        os.remove(token)
627
628                return dpkg_status,result                       
629
630       
631               
632        #def check_install_remove       
633
634        def postinstall_app(self):
635       
636
637                cmd=""
638               
639                if len(self.epi_conf["script"])>0:
640                        self.token_result_postinstall=tempfile.mkstemp("_result_postinstall")
641                        script=self.epi_conf["script"]["name"]
642                        if os.path.exists(script):
643                                cmd=script + ' postInstall; echo $? >' + self.token_result_postinstall[1] +';'
644
645                return cmd     
646
647        #def postinstall_app   
648       
649        def check_postinstall(self):
650               
651                result=True
652
653                try:
654                        if os.path.exists(self.token_result_postinstall[1]):
655                                file=open(self.token_result_postinstall[1])
656                                content=file.readline()
657                                if '0' not in content:
658                                        result=False
659                                file.close()
660                                os.remove(self.token_result_postinstall[1])
661                except:
662                        pass                   
663
664                return result
665
666        #def check_postinstall 
667
668        def remove_repo_keys(self):
669       
670                if os.path.exists(self.epi_sources):
671                        os.remove(self.epi_sources)     
672
673                if os.path.exists(self.epi_keyring):
674                        os.remove(self.epi_keyring)     
675
676        #def remove_repo_keys   
677
678        def uninstall_app(self,order):
679
680                cmd=""
681
682                if self.epiFiles[order]["script"]["remove"]:
683                        self.token_result_remove=tempfile.mkstemp("_result_remove")
684                        script=self.epiFiles[order]["script"]["name"]
685                        if os.path.exists(script):
686                                cmd=script + ' remove; echo $? >' + self.token_result_remove[1] + ';'
687
688                return cmd
689
690        #def uninstall_app     
691
692        def zerocenter_feedback(self,order,action,result=None):
693
694                zomando_name=self.zomando_name[order]
695
696                if zomando_name!="":
697                        if action=="init":
698                                cmd="zero-center add-pulsating-color " +zomando_name
699                        elif action=="install":
700                                if result:
701                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-configured " +zomando_name
702                                       
703                                else:
704                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-failed " +zomando_name
705                        elif action=="uninstall":
706                                if result:
707                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-non-configured " +zomando_name
708                                else:
709                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-failed " +zomando_name
710
711                        os.system(cmd)         
712
713        #def zero-center_feedback       
714
715
716#class ApplicationInstallerManager
717
718
719if __name__=="__main__":
720       
721        epi=EpiManager()
Note: See TracBrowser for help on using the repository browser.