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

Last change on this file since 7818 was 7818, checked in by jrpelegrina, 2 years ago

WIP configure wget without checking certificate

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