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

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

Fix file

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