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

Last change on this file since 6717 was 6717, checked in by jrpelegrina, 20 months ago

Fixed files and addded logrotate

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                        epi_load=json.load(f)
65                        epi_conf=self.epi_base.copy()
66                        f.close()
67                        epi_conf.update(epi_load)
68                        self.epiFiles[self.order]=epi_conf
69                        self.zomando_name[self.order]=epi_conf["zomando"]
70                        try:
71                                if epi_conf["depends"]!="":
72                                        self.order=self.order+1
73                                        self.read_conf(epi_conf["depends"])
74                        except :
75                                pass           
76
77        #def read_conf         
78
79
80        def get_pkg_info(self):
81
82                pkg_list=[]
83                self.pkg_info={}
84                tmp_list=self.epiFiles.copy()
85
86                for item in tmp_list:
87                        pkg_list=[]
88                        pkg_list=tmp_list[item]["pkg_list"]
89                       
90                        info=self.get_store_info(pkg_list,item)
91
92                        cont=0
93
94                        for element in pkg_list:
95                                name=element["name"]
96                                if info[name]["status"]=="installed":
97                                        cont=cont+1
98
99                        if cont==len(pkg_list):
100                                if item>0:
101                                        self.epiFiles.pop(item)
102                                        self.zomando_name.pop(item)
103                                else:
104                                        self.epiFiles[item]["status"]="installed"
105                                        self.pkg_info.update(info)
106                        else:
107                                self.epiFiles[item]["status"]="availabled"
108                                self.pkg_info.update(info)     
109
110        #def get_pkg_info                               
111                                                       
112
113        def get_store_info(self,pkg_list,order):                       
114
115                        pkg_info={}
116                        self.getStatus_byscript=False
117
118                        try:
119                                if self.epiFiles[order]["script"]["getStatus"]:
120                                        self.getStatus_byscript=True
121                        except:
122                                pass
123
124                       
125                        for item in pkg_list:
126                                app=item["name"]
127                                name=""
128                                summary=""
129                                status=""
130                                description=""
131                                icon=""
132                                debian_name=""
133                                component=""
134                                try:
135                                        pkg=item["key_store"]
136                                        action="info"
137                                        self.storeManager.execute_action(action,pkg)
138                                        while self.storeManager.is_action_running(action):
139                                                time.sleep(0.2)
140
141                                        ret=self.storeManager.get_status(action)
142
143                                        if ret["status"]==0:
144                                                data=self.storeManager.get_result(action)
145
146                                                if len(data)>0:
147
148                                                        if not self.getStatus_byscript:
149                                                                if (data["info"][0]["state"]) !="":
150                                                                        status=data["info"][0]["state"]
151                                                                else:
152                                                                        status=self.check_pkg_status(app,order)
153                                                        else:
154                                                                status=self.check_pkg_status(app,order)         
155                                                               
156
157                                                        description=data["info"][0]["description"]
158                                                        icon=data["info"][0]["icon"]
159                                                        name=data["info"][0]["name"]
160                                                        summary=data["info"][0]["summary"]
161                                                        debian_name=data["info"][0]["package"]
162                                                        component=data["info"][0]["component"]
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                               
173                                pkg_info[app]={}
174                                pkg_info[app]["debian_name"]=debian_name
175                                pkg_info[app]["component"]=component
176                                pkg_info[app]["status"]=status
177                                pkg_info[app]["description"]=description
178                                pkg_info[app]["icon"]=icon
179                                pkg_info[app]["name"]=name
180                                pkg_info[app]["summary"]=summary
181
182                        return pkg_info
183
184        #def get_store_info                     
185
186        def check_pkg_status(self,pkg,order=None):
187       
188
189                if self.getStatus_byscript:
190                        if order !=None:
191                                if len(self.epiFiles[order]["script"])>0:
192                                        try:
193                                                script=self.epiFiles[order]["script"]["name"]
194                                                if os.path.exists(script):
195                                                        cmd=script +' getStatus ' + pkg;
196                                                        p=subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE)
197                                                        poutput=p.communicate()
198                                                        if len(poutput)>0:
199                                                                if poutput[0].decode("utf-8").split("\n")[0]=='0':
200                                                                        return "installed"
201                                               
202                                        except Exception as e:
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                                                               
310                self.arquitecture=True
311                return cmd             
312
313        #def check_arquitecture
314       
315        def add_repository_keys(self,order):
316
317                self.epi_conf=self.epiFiles[order]
318
319                cmd=""
320                self.type=self.epi_conf["type"]
321
322                if self.type=="apt":
323
324                        repos_list=self.epi_conf["repository"]
325
326                        if len(repos_list)>0:
327                                f = open(self.epi_sources,'w')
328                                for item in repos_list:
329                                        if item["url"]!="":
330                                                lines=item["url"].split(";")
331                                                for line in lines:
332                                                        f.write(line+'\n')
333                                        try:
334                                                key_cmd=item["key_cmd"]
335                                                if key_cmd !="":
336                                                        cmd=cmd+key_cmd+';'     
337                                        except Exception as e:
338                                                if len(self.epi_conf["script"])>0:
339                                                        try:
340                                                                if self.epi_conf["script"]["addRepoKeys"]:
341                                                                        script=self.epi_conf["script"]["name"]
342                                                                        if os.path.exists(script):
343                                                                                command=script + ' addRepoKeys;'
344                                                                                cmd=cmd+command
345                                                        except Exception as e:
346                                                                #print (str(e))
347                                                                pass
348
349                                f.close()
350                                self.update=True
351
352                       
353                return cmd             
354
355        #def add_repository_keys       
356
357
358        def get_app_version(self,item=None):
359
360                self.force32=self.epi_conf["force32"]
361
362                if self.force32:
363                        version=item["version"]["32b"]
364                       
365                else:
366                        try:
367                                version=item["version"]["all"]
368                        except Exception as e:
369                                if platform.architecture()[0]=='64bit': 
370                                        version=item["version"]["64b"]
371                                else:
372                                        version=item["version"]["32b"]
373                       
374                return version
375
376        #def get_app_version   
377                                               
378        def download_app(self):
379
380                self.manage_download=True
381                self.download_folder={}
382                cmd=""
383
384                self.type=self.epi_conf["type"]
385                if self.type !='apt':
386
387                        self.token_result_download=tempfile.mkstemp("_result_download")
388                       
389                        if self.type=="file":
390                                if len(self.epi_conf["script"])>0:
391                                        try:
392                                                if self.epi_conf["script"]["download"]:
393                                                        script=self.epi_conf["script"]["name"]
394                                                        if os.path.exists(script):
395                                                                cmd=script +' download; echo $? >' + self.token_result_download[1] +';'
396                                                                self.manage_download=False
397                                        except:
398                                                pass                   
399
400                        if self.manage_download:
401
402                                for item in self.epi_conf["pkg_list"]:
403                                        version=self.get_app_version(item)
404                                        if self.type=="deb":
405                                                name=item["name"]+".deb"
406                                                tmp_file=os.path.join(self.download_path,name)
407                                        else:
408                                                try:
409                                                        tmp_file=os.path.join(self.download_path,item["alias_download"])
410                                                except Exception as e: 
411                                                        #name=item["name"]
412                                                        tmp_file=os.path.join(self.download_path,version)
413                               
414                                        url=item["url_download"]
415                                       
416                                        if os.path.exists(tmp_file):
417                                                cmd=cmd+'rm -f '+ tmp_file +';'
418                                        self.download_folder["name"]=tmp_file
419                                        cmd=cmd+'wget ' +url+version + ' --progress=bar:force -O ' + tmp_file +'; '
420
421                                cmd=cmd + ' echo $? >' + self.token_result_download[1] +';'     
422                       
423
424                return cmd                     
425                                       
426        #def download_app               
427
428
429        def check_download(self):
430
431               
432                result=True
433
434                if self.type !='apt':
435
436                       
437                        if os.path.exists(self.token_result_download[1]):
438                                file=open(self.token_result_download[1])
439                                content=file.readline()
440                                if '0' not in content:
441                                        result=False
442                                file.close()
443                                os.remove(self.token_result_download[1])
444
445                                if result:     
446                                        if self.manage_download:
447                                                pkgs_todownload=len(self.download_folder)
448                                                cont=0
449
450                                                for item in self.download_folder:
451                                                        if os.path.exists(self.download_folder[item]):
452                                                                cont=cont+1
453
454                                                if cont != pkgs_todownload:
455                                                        result=False
456
457                return result
458
459        #def check_download             
460
461        def preinstall_app(self):
462       
463
464                cmd=""
465
466                if len(self.epi_conf["script"])>0:
467                        self.token_result_preinstall=tempfile.mkstemp("_result_preinstall")
468                        script=self.epi_conf["script"]["name"]
469                        if os.path.exists(script):
470                                cmd=script +' preInstall; echo $? >' + self.token_result_preinstall[1] +';'
471
472                return cmd             
473
474        #def preinstall_app     
475       
476
477        def check_preinstall(self):
478               
479                result=True
480
481                try:
482                        if os.path.exists(self.token_result_preinstall[1]):
483                                file=open(self.token_result_preinstall[1])
484                                content=file.readline()
485                                if '0' not in content:
486                                        result=False
487                                file.close()
488                                os.remove(self.token_result_preinstall[1])
489
490                except:                 
491                        pass
492
493                return result
494
495
496        #def check_preinstall_app       
497
498        def install_app(self):
499       
500                add_i386=""
501               
502                if not self.arquitecture:
503                        add_i386=self.check_arquitecture()
504
505
506                cmd=""
507               
508                if self.type=="apt":
509
510                        update_repos=self.check_update_repos()
511                        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 "
512                        for item in self.epi_conf["pkg_list"]:
513                                app=item["name"]
514                                cmd=cmd + app +" "
515
516       
517                       
518                elif self.type=="deb":
519                       
520                        cmd=add_i386 + "dpkg -i "
521                        for item in self.epi_conf["pkg_list"]:
522                                name=item["name"]+".deb"
523                                pkg=self.download_folder["name"]
524                                cmd=cmd+pkg +" "
525
526                       
527                else:
528                        self.token_result_install=tempfile.mkstemp("_result")
529                        script=self.epi_conf["script"]["name"]
530                        if os.path.exists(script):
531                                cmd=script + ' installPackage; echo $? >' + self.token_result_install[1]
532
533                cmd=cmd+";"
534                return cmd     
535
536        #def install_app       
537
538
539        def check_install_remove(self,action):
540
541                dpkg_status={}
542                cont=0
543                token=""
544               
545                if action=="install":
546                               
547                        if self.type !="file":
548                                pkgs=self.epi_conf["pkg_list"]
549                       
550                                for item in pkgs:
551                                        status=self.check_pkg_status(item["name"])
552                               
553                                        if status=="installed":
554                                                cont=cont+1
555                               
556                                        dpkg_status[item["name"]]=status
557
558                                if cont==len(pkgs):
559                                        result=True
560               
561                                else:
562                                        result=False
563
564                        else:
565                                token=self.token_result_install[1]     
566                                if os.path.exists(token):
567                                        file=open(token)
568                                        content=file.readline()
569                                        if '0' not in content:
570                                                result=False
571                                        else:
572                                                result=True     
573                                                                               
574                                        file.close()
575                                        os.remove(token)
576
577                else:
578               
579                        if self.epiFiles[0]["type"] !="file":
580                                        pkgs=self.epiFiles[0]["pkg_list"]                       
581                                        for item in pkgs:
582                                                status=self.check_pkg_status(item["name"])
583                                                if status!="installed":
584                                                        cont=cont+1
585                                                dpkg_status[item["name"]]=status
586
587               
588                        token=self.token_result_remove[1]
589                        if os.path.exists(token):
590                                        file=open(token)
591                                        content=file.readline()
592                                        if '0' not in content:
593                                                result=False
594                                        else:
595                                                result=True     
596                                                       
597                                        file.close()
598                                        os.remove(token)
599
600                return dpkg_status,result                       
601
602       
603               
604        #def check_install_remove       
605
606        def postinstall_app(self):
607       
608
609                cmd=""
610               
611                if len(self.epi_conf["script"])>0:
612                        self.token_result_postinstall=tempfile.mkstemp("_result_postinstall")
613                        script=self.epi_conf["script"]["name"]
614                        if os.path.exists(script):
615                                cmd=script + ' postInstall; echo $? >' + self.token_result_postinstall[1] +';'
616
617                return cmd     
618
619        #def postinstall_app   
620       
621        def check_postinstall(self):
622               
623                result=True
624
625                try:
626                        if os.path.exists(self.token_result_postinstall[1]):
627                                file=open(self.token_result_postinstall[1])
628                                content=file.readline()
629                                if '0' not in content:
630                                        result=False
631                                file.close()
632                                os.remove(self.token_result_postinstall[1])
633                except:
634                        pass                   
635
636                return result
637
638        #def check_postinstall 
639
640        def remove_repo_keys(self):
641       
642                if os.path.exists(self.epi_sources):
643                        os.remove(self.epi_sources)     
644
645                if os.path.exists(self.epi_keyring):
646                        os.remove(self.epi_keyring)     
647
648        #def remove_repo_keys   
649
650        def uninstall_app(self,order):
651
652                cmd=""
653
654                if self.epiFiles[order]["script"]["remove"]:
655                        self.token_result_remove=tempfile.mkstemp("_result_remove")
656                        script=self.epiFiles[order]["script"]["name"]
657                        if os.path.exists(script):
658                                cmd=script + ' remove; echo $? >' + self.token_result_remove[1] + ';'
659
660                return cmd
661
662        #def uninstall_app     
663
664        def zerocenter_feedback(self,order,action,result=None):
665
666                zomando_name=self.zomando_name[order]
667
668                if zomando_name!="":
669                        if action=="init":
670                                cmd="zero-center add-pulsating-color " +zomando_name
671                        elif action=="install":
672                                if result:
673                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-configured " +zomando_name
674                                       
675                                else:
676                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-failed " +zomando_name
677                        elif action=="uninstall":
678                                if result:
679                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-non-configured " +zomando_name
680                                else:
681                                        cmd="zero-center remove-pulsating-color "+zomando_name + " ;zero-center set-failed " +zomando_name
682
683                        os.system(cmd)         
684
685        #def zero-center_feedback       
686
687
688#class ApplicationInstallerManager
689
690
691if __name__=="__main__":
692       
693        epi=EpiManager()
Note: See TracBrowser for help on using the repository browser.