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

Last change on this file since 6655 was 6655, checked in by jrpelegrina, 3 years ago

Fix code

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