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

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

Add pyhto3-epi files

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