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

Last change on this file since 8180 was 8180, checked in by Juanma, 14 months ago

improved performance

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