source: lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py @ 8223

Last change on this file since 8223 was 8223, checked in by Juanma, 13 months ago

Implemented cache

File size: 6.1 KB
Line 
1import syslog
2import gi
3gi.require_version('PackageKitGlib', '1.0')
4from gi.repository import PackageKitGlib as packagekit
5import threading
6import time
7from queue import Queue as pool
8class debmanager:
9        def __init__(self):
10                self.installer=''
11                self.dbg=False
12                self.result=[]
13                self.progress=0
14                self.partial_progress=0
15                self.plugin_actions={'install':'deb','remove':'deb','pkginfo':'deb','policy':'deb'}
16                self.result={}
17                self.result['data']={}
18                self.result['status']={}
19                self.count=0
20        #def __init__
21
22        def set_debug(self,dbg=True):
23                self.dbg=dbg
24                #self._debug ("Debug enabled")
25        #def set_debug
26
27        def _debug(self,msg=''):
28                if self.dbg:
29                        print ('DEBUG Deb: %s'%msg)
30        #def debug
31
32        def register(self):
33                return(self.plugin_actions)
34        #def register
35       
36        #filter=1 -> app available
37        #filter=2 -> only installed app installed
38        def execute_action(self,action,applist,filters=1):
39                #self._debug("Executing action %s"%action)
40                self.progress=0
41                self.installer=packagekit.Client()
42                self.count=len(applist)
43                self.result['status']={'status':-1,'msg':''}
44                self.result['data']=[]
45                processedPkg=[]
46                #1.- If the app doesn't exist cancel the action
47                for app_info in applist:
48                        if app_info['package'] not in processedPkg:
49                                processedPkg.append(app_info['package'])
50                                if action=='remove':
51                                        filters=2
52                                app=self._resolve_App(app_info['package'],filters)
53                                if app:
54                                        if action=='install':
55                                                self._install_App(app)
56                                                self.result['data'].append({'package':app_info['package']})
57                                        if action=='remove':
58                                                self._remove_App(app)
59                                                self.result['data'].append({'package':app_info['package']})
60                                        if action=='pkginfo':
61                                                res=self._get_info(app_info,app)
62                                                self.result['data'].append(res)
63                                        if action=='policy':
64                                                self._set_status(0)
65                                                self.result['data'].append({'id':app.get_id()})
66                                self.progress=self.progress+(self.partial_progress/self.count)
67                self.progress=100
68                return(self.result)
69        #def execute_action
70
71        def _set_status(self,status,msg=''):
72                self.result['status']={'status':status,'msg':msg}
73        #def _set_status
74
75        def _fake_callback(self,*args):
76                pass
77        #def _fake_callback
78
79        def _callback(self,status,typ,data=None):
80                self.partial_progress=status.props.percentage
81                self.progress=self.partial_progress/self.count
82        #def _callback
83
84        def _install_App(self,app):
85                self.return_msg=False
86                #self._debug("Installing %s"%app.get_id())
87                err=0
88                try:
89                        self.installer.install_packages(True,[app.get_id(),],None,self._callback,None)
90                        err=0
91                except Exception as e:
92                        print(str(e))
93                        #self._debug("Install error: %s"%e.code)
94                        err=e.code
95                finally:
96                        self.partial_progress=100
97                self._set_status(err)
98                return err
99        #def _install_App_from_Repo
100                       
101        def _remove_App(self,app):
102                try:
103                        self.installer.remove_packages(True,[app.get_id(),],True,False,None,self._callback,None)
104                        self._set_status(0)
105                except Exception as e:
106                        #self._debug("Remove error: %s"%e.code)
107                        #self._debug("Remove error: %s"%e)
108                        self._set_status(e.code)
109                finally:
110                        self.partial_progress=100
111        #def _remove_App
112
113        def _th_get_details(self,pkTask,app_info_pool,app):
114                #self._debug("Getting details for %s"%app.get_id())
115                results=pkTask.get_details([app.get_id(),],None,self._fake_callback,None)
116                for app_detail in results.get_details_array():
117                        app_info_pool.put({'size':str(app_detail.get_size())})
118                        break
119        #def _th_get_details
120
121        def _th_get_depends(self,pkTask,app_info_pool,app):
122                #self._debug("Getting dependencies for %s"%app.get_id())
123                results=pkTask.get_depends(1,[app.get_id(),],False,None,self._fake_callback,None)
124                dependsList=[]
125                for related_app in results.get_package_array():
126                        dependsList.append(related_app.get_id())
127                app_info_pool.put({'depends':dependsList})
128        #def _th_get_depends
129
130        def _get_info(self,app_info,app):
131                app_info['version']=app.get_version()
132                app_info['arch']=app.get_id().split(';')[2]
133                pkTask=packagekit.Task()
134                results=[]
135                self._set_status(0)
136                #Only get size and depends if we don't have the data
137                if not app_info['size']:
138                        app_info_pool=pool()
139                        threads=[]
140                        th=threading.Thread(target=self._th_get_details, args = (pkTask,app_info_pool,app))
141                        threads.append(th)
142                        th.start()
143                        #Get depends disabled per time-costing
144                        #th=threading.Thread(target=self._th_get_depends, args = (pkTask,app_info_pool,app))
145                        #threads.append(th)
146                        #th.start()
147                        for thread in threads:
148                                try:
149                                        thread.join()
150                                except:
151                                        pass
152                        while app_info_pool.qsize():
153                                data=app_info_pool.get()
154                                app_info.update(data)
155                #Get status
156                try:
157                        info=app.get_info()
158                        state=info.to_string(info)
159                        if state!=app_info['state'] and state!='available' and app_info['state']=='installed':
160                                app_info['updatable']=1
161                        else:
162                                app_info['state']=state
163                        #self._debug("State: %s"%state)
164                except Exception as e:
165                        #self._debug("State: not available (%s)"%e)
166                        pass
167                #self._debug("INFO: %s"%app_info)
168                return(app_info)
169        #def _get_info
170
171        def _resolve_App(self,app_name,filters=1):
172                #self._debug("Resolving %s"%app_name)
173                def _pk_resolve(filters,app_name):
174                        app=None
175                        #self._debug("Filter for resolver: %s"%filters)
176                        result=self.installer.resolve(filters,[app_name,],None,self._fake_callback, None)
177                        resolvelist=result.get_package_array()
178                        #resolver bug: filters not work so if we want to remove an app first we must get the installed version...
179                        app_resolved=None
180                        if filters==1:
181                                app_resolved=resolvelist[0]
182                        elif filters==2:
183                                for app in resolvelist:
184                                        if (str(app.get_info()).find('PK_INFO_ENUM_INSTALLED')!=-1):
185                                                app_resolved=app
186                                                break
187                        if app_resolved:
188                                #self._debug("Application %s resolved succesfully"%app_resolved.get_name())
189                                app=app_resolved
190                        else:
191                                #self._debug("Application %s NOT resolved"%app_resolved.get_name())
192                                pass
193                        return app
194
195                app=None
196                resolvelist=[]
197                self.return_msg=False
198                try:
199                        app=_pk_resolve(filters,app_name)
200                except Exception as e:
201                        #self._debug("Couldn't resolve %s"%app_name)
202                        #self._debug("Reason: %s"%e)
203                        #self._debug("2nd attempt")
204                        time.sleep(0.5)
205                        try:
206                                app=_pk_resolve(filters,app_name)
207                        except Exception as e:
208                                #self._debug("Couldn't resolve %s"%app_name)
209                                #self._debug("Reason: %s"%e)
210                                pass
211                finally:
212                        self.partial_progress=100
213                return(app)
214        #def _resolve_App
215
Note: See TracBrowser for help on using the repository browser.