source: lliurex-store/trunk/fuentes/lliurex-appstore.install/usr/bin/storeManager.py @ 3099

Last change on this file since 3099 was 3099, checked in by Juanma, 4 years ago

wip on plugin architecture

File size: 16.4 KB
Line 
1import sys
2import gi
3import locale
4import os
5import time
6gi.require_version('AppStreamGlib', '1.0')
7from gi.repository import AppStreamGlib as appstream
8from gi.repository import Gio
9import threading
10import plugins
11
12######
13#Ver. 1.0 of storeManager.py
14# This class manages the store and the related plugins
15# It's implemented as an action-drived class.
16# There're four(five) main actions and each of them could execute and undeterminated number of subprocess in their respective thread
17# Each of these actions returns EVER a list of dictionaries.
18#####
19
20class StoreManager:
21        def __init__(self,args=()):
22                self.store=appstream.Store()
23                self.relatedActions={
24                                        'load':['load'],
25                                        'search':['search','info','pkginfo'],
26                                        'list':['list','info','pkginfo'],
27                                        'list_sections':['list_sections'],
28                                        'install':['search','info','pkginfo','install'],
29                                        'remove':['search','info','pkginfo','remove']
30                                        }
31                if locale.getdefaultlocale()[0]=="es_ES":
32                        self.locale=['es_ES','es','ca@valencia','ca','ca_ES','C']
33                else:
34                        self.locale=[locale.getlocale()[0],'ca@valencia','ca','es','es_ES','C']
35                self.dbg=1
36                self.threads={}                         #Dict that stores the functions that must execute each action
37                self.threadsProgress={}                 #"" "" "" the progress for each launched thread
38                self.threadsRunning={}                  #"" "" "" the running threads
39                self._define_functions_for_threads()    #Function that loads the dictionary self.threads
40                self.pluginDir=os.getcwd()+'/plugins'           #Path to the dir that stores the plugins
41                self.pluginMod=os.path.basename(self.pluginDir) #DON'T CHANGE!!!       
42                oldpwd=os.getcwd()
43                os.chdir(self.pluginDir)
44                exec ('import ' + self.pluginMod)               #DON'T CHANGE!!!
45                os.chdir(oldpwd)
46                self.registeredPlugins={}               #Dict that have the relation between plugins and actions
47                self.registerProcessProgress={}         #Dict that stores the progress for each function/parentAction pair
48                self.__init_plugins__()                 #Function that loads the plugins
49                self.progressActions={}                 #Progress of global actions based on average progress of individual processes
50                self.result={}                          #Result of the actions
51                self.execute_action('load')             #Function that launches the actions
52                self.lock=threading.Lock()              #locker for functions related to threads (get_progress, is_action_running...)
53        #def __init__
54
55        ####
56        #Load and register the plugins from plugin dir
57        ####
58        def __init_plugins__(self):
59                os.chdir(self.pluginDir)
60                for mod in os.listdir():
61                        if not  mod.startswith('_'):
62                                modName=mod.split('.')[0]
63                                strImport='from plugins.'+modName+' import *'
64                                try:
65                                        exec (strImport)
66                                except Exception as e:
67                                        print(str(e))
68                for mod in (sys.modules.keys()):
69                        if 'plugins.' in mod:
70                                definedActions={}
71                                pluginNameUp=mod.split('.')[-1]
72                                pluginName=pluginNameUp.lower()
73                                try:
74                                        loadedClass=eval(mod+'.'+pluginName)()
75                                        definedActions=loadedClass.register()
76                                except Exception as e:
77                                        print ("Can't initialize "+str(mod)+' '+str(loadedClass))
78                                        print ("Reason: "+str(e))
79                                        pass
80                       
81                                for action in definedActions.keys():
82                                        if action not in self.registeredPlugins:
83                                                self.registeredPlugins[action]={}
84                                        self.registeredPlugins[action].update({definedActions[action]:pluginNameUp+'.'+pluginName})
85                self._debug(str(self.registeredPlugins))
86        #def __init_plugins__
87
88        def set_debug(self,dbg='1'):
89                self.dbg=int(dbg)
90                self._debug ("Debug enabled")
91        #def set_debug
92
93        def _debug(self,msg=''):
94                if self.dbg==1:
95                        print ('DEBUG Store: '+msg)
96        #def _debug
97
98        ####
99        #dict of actions/related functions for threading
100        ####
101        def _define_functions_for_threads(self):
102                self.threads['load']="threading.Thread(target=self._load_Store)"
103                self.threads['info']="threading.Thread(target=self._get_App_Info,args=[args])"
104                self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,args=[args])"
105                self.threads['search']='threading.Thread(target=self._search_Store,args=[args,action])'
106                self.threads['list']='threading.Thread(target=self._search_Store,args=[args,action])'
107                self.threads['install']='threading.Thread(target=self._install_remove_App,args=[args,action])'
108                self.threads['remove']='threading.Thread(target=self._install_remove_App,args=[args,action])'
109                self.threads['list_sections']='threading.Thread(target=self._list_sections,args=[args,action])'
110        #def _define_functions_for_threads
111
112        ####
113        #Launch the appropiate threaded function for the desired action
114        #Input:
115        #  - action to be executed
116        #  - parms for the action
117        ####
118        def execute_action(self,action,args=None):
119                self._debug("Launching action: "+action)
120                if self.is_action_running('load'):
121                        self._join_action('load')
122                if action in self.threads.keys():
123#                       self.action=action
124                        if self.is_action_running(action):
125                                #join thread if we're performing the same action
126                                self._debug("Waiting for current action "+action+" to end")
127                                self.threadsRunning[action].join()
128                        try:
129                                if action in self.progressActions.keys():
130                                        self.progressActions[action]=0
131                                self.progressActions[action]=0
132                                self.threadsRunning[action]=eval(self.threads[action])
133                                self.threadsRunning[action].start()
134                                self._debug("Thread "+str(self.threadsRunning[action])+" for action "+action+" launched")
135                        except Exception as e:
136                                self._debug("Can't launch thread for action: "+action)
137                                self._debug("Reason: "+str(e))
138                                pass
139                else:
140                        self._debug("No function associated with action "+action)
141        #def execute_action
142
143        ####
144        #Launch the appropiate class function
145        #Input:
146        #  - class action to be executed
147        #  - parms for the action
148        #  - parent action that demands the execution
149        #Output
150        #  - The class method to execute
151        ####
152        def _execute_class_method(self,action,parms=None,launchedby=None):
153                if not parms:
154                        parms="*"
155                self._debug("Plugin for "+action+": "+self.registeredPlugins[action][parms])
156#               exeFunction=eval(self.pluginDir+'.'+self.registeredPlugins[action][parms]+"()")
157                exeFunction=eval(self.pluginMod+'.'+self.registeredPlugins[action][parms]+"()")
158#               exeFunction=exec(self.pluginMod+'.'+self.registeredPlugins[action][parms]+"()")
159                self._registerProcessProgress(action,exeFunction,launchedby)
160                return (exeFunction)
161        #def _execute_class_method
162
163        ###
164        #Tell if a a action is running
165        #Input:
166        #  - action to monitorize
167        #Output:
168        #  - status true/false
169        ###
170        def is_action_running(self,action=None):
171                status=False
172                if action:
173                        if action in self.threadsRunning:
174                                if self.threadsRunning[action].is_alive():
175                                        status=True
176                                else:
177                                        if action in self.relatedActions.keys():
178                                                for relatedAction in self.relatedActions[action]:
179                                                        if relatedAction in self.threadsRunning.keys():
180                                                                if self.threadsRunning[relatedAction].is_alive():
181                                                                        status=True
182                                                                        break
183#                                       self._debug(action+" running: "+str(status))
184                else:
185                        if (threading.active_count()-1):
186                                status=True
187#                               self._debug("Running: "+str(threading.active_count()) + " threads")
188                return(status)
189        #def is_action_running
190
191        ####
192        #Joins an action till finish
193        #Input:
194        #  - action to join
195        ####
196        def _join_action(self,action):
197                self._debug("Joining action: "+action)
198                try:
199                        self.threadsRunning[action].join()
200                except Exception as e:
201                        self._debug("Unable to join thread for: "+action)
202                        self._debug("Reason: "+ str(e))
203                finally:               
204                        if action in self.threadsRunning:
205                                del(self.threadsRunning[action])
206        #def _join_action
207
208        ####
209        #Register the method and action/parentAction pair in the progress dict
210        #Input:
211        #  - action launched
212        #  - function (a reference to the function)
213        #  - parentAction that owns the action (if any)
214        ####
215        def _registerProcessProgress(self,action,function,parentAction=None):
216                if action in self.registerProcessProgress:
217                        self._debug("Appended process for action :"+action +" and function: "+str(function))
218                        self.registerProcessProgress[action].append(function)
219                else:
220                        self._debug("Registered process for action :"+action+" and function: "+str(function))
221                        self.registerProcessProgress[action]=[function]
222                if parentAction:
223                        self._debug("Registered process for Parent Action :"+action+"-"+parentAction+" and function: "+str(function))
224                        if parentAction in self.threadsProgress.keys():
225                                self.threadsProgress[parentAction].update({action:function})
226                        else:
227                                self.threadsProgress[parentAction]={action:function}
228        #def _registerProcessProgress
229
230
231        ####
232        #Get the progress of the executed actions
233        #Input
234        #  - action or none if we want all of the progress
235        #Output:
236        #  - Dict of results indexed by actions
237        ####
238        def get_progress(self,action=None):
239                progress={'search':0,'list':0,'install':0,'remove':0,'load':0,'list_sections':0}
240                actionList=[]
241                if action and action in self.registerProcessProgress:
242                        actionList=[action]
243                else:
244                        actionList=self.registerProcessProgress.keys()
245                self.lock.acquire() #prevent that any thread attempts to change the iterator
246                for parentAction in self.relatedActions.keys():
247                        if self.is_action_running(parentAction):
248                                for action in actionList:
249                                        if parentAction in self.threadsProgress.keys():
250#                                               self._debug(str(len(self.threadsProgress[parentAction]))+" Threads for action "+parentAction+": "+str(self.threadsProgress[parentAction]))
251                                                acumProgress=0
252                                                for threadfunction in self.threadsProgress[parentAction]:
253                                                        function=self.threadsProgress[parentAction][threadfunction]
254#                                                       self._debug(str(function)+" "+ str(threadfunction) + " "+parentAction)
255                                                        acumProgress=acumProgress+function.progress
256#                                                       self._debug("Acum for process "+parentAction+": "+str(acumProgress))
257       
258                                                count=len(self.relatedActions[parentAction])
259                                                acumprogress=round(acumProgress/count,0)
260#                                               self._debug("Assign result for action" +action)
261                                                self.progressActions[parentAction]=round(acumProgress/count,0)
262                                                progress[parentAction]=round(acumProgress/count,0)
263                        else:
264                                #put a 100% just in case
265                                if parentAction in self.progressActions.keys():
266#                                       if self.progressActions[parentAction]:
267#                                               self.progressActions[parentAction]=100
268                                        self.progressActions[parentAction]=100
269                self.lock.release()
270#               self._debug("Progress :"+str(progress))
271                return(self.progressActions)
272        #def get_progress
273
274        ####
275        #Gets the result of an action
276        #Input:
277        #  - action
278        #Output:
279        #  - Dict of results indexed by actions
280        ####
281        def get_result(self,action=None):
282                self.lock.acquire() #Prevent changes on results from threads
283                result={}
284                if action==None:
285                        result=self.result
286                else:
287                        if self.is_action_running(action):
288                                self._join_action(action)
289                        result[action]=None
290                        if action in self.result:
291                                result[action]=self.result[action]
292                self.lock.release()
293                return(result)
294        #def get_result
295
296        ####
297        #Loads the store
298        ####
299        def _load_Store(self):
300                action='load'
301                loadFunction=self._execute_class_method(action)
302                self.store=loadFunction.execute_action(action,self.store)
303        #def _load_Store
304
305        ####
306        #Loads the info related to one app
307        #Input:
308        #  - List of App objects
309        #Output:
310        #  - Dict with the related info
311        ####
312        def _get_App_Info(self,applist,launchedby=None):
313                action='info'
314                infoFunction=self._execute_class_method(action,None,launchedby)
315                applistInfo=infoFunction.execute_action(self.store,action,applist)
316                return(applistInfo)
317        #def _get_App_Info
318
319        ####
320        #Loads the extended info related to one app (slower)
321        #Input:
322        #  - Dict off Apps (as returned by _get_app_info)
323        #Output:
324        #  - Dict with the related info
325        ####
326        def _get_Extended_App_Info(self,applistInfo,launchedby=None,fullsearch=True):
327                #Check if there's any plugin for the distinct type of packages
328                action='pkginfo'
329                typeDict={}
330                for appInfo in applistInfo:
331                        package_type=self._check_package_type(appInfo)
332                        if package_type in typeDict:
333                                typeDict[package_type].append(appInfo)
334                        else:
335                                typeDict[package_type]=[appInfo]
336                for package_type in typeDict:
337                        self._debug("Checking plugin for "+action+ " "+package_type)
338                        if package_type in self.registeredPlugins[action]:
339                                #Only search deb's full info if there's only one package
340                                if package_type=='deb' and (len(typeDict[package_type])!=1 or fullsearch==False):
341                                        continue
342                                pkgInfoFunction=self._execute_class_method(action,package_type,launchedby)
343                                pkgInfoFunction.execute_action(action,typeDict[package_type])
344                return(applistInfo)
345        #def _get_Extended_App_Info
346
347        def _list_sections(self,searchItem='',action='list_sections',launchedby=None):
348                result={}
349                self._debug("Retrieving all sections")
350                if action in self.registeredPlugins.keys():
351                        self._debug("Plugin for generic search: "+self.registeredPlugins[action]['*'])
352                        finder=self.registeredPlugins[action][('*')]
353                        searchFunction=eval(self.pluginMod+'.'+finder+"()")
354                        result=searchFunction.execute_action(self.store,action,searchItem)
355                else:
356                        print("No plugin for action "+action)
357                self.result[action]=result
358                self._debug("Sections: "+str(self.result[action]))
359
360        ####
361        #Search the store
362        #Input:
363        #  - string search
364        #Output:
365        #  - List of dicts with all the info
366        ####
367        def _search_Store(self,searchItem='',action='search',fullsearch=True,launchedby=None):
368                applist={}
369                aux_applist=[]
370                if action=='list':
371                        try:
372                                searchItem=' '.join(searchItem)
373                        except:
374                                searchItem=''
375                if action=='list_sections':
376                        searchItem=''
377                if (searchItem in self.registeredPlugins[action]):
378                        self._debug("Plugin for search "+ searchItem +": "+self.registeredPlugins[action][searchItem])
379                        finder=self.registeredPlugins[action][searchItem]
380                else:
381                        self._debug("Plugin for generic search: "+self.registeredPlugins[action]['*'])
382                        finder=self.registeredPlugins[action][('*')]
383                #Tokenize the search if there're multiple items
384                if len(searchItem.split(' '))>1 or action=='list':
385                        self._debug("Tokenizing search items")
386                        searchItem=appstream.utils_search_tokenize(searchItem)
387                else:
388                        searchItem=[searchItem]
389#               searchFunction=eval(finder+"()")
390                searchFunction=eval(self.pluginMod+'.'+finder+"()")
391                if not launchedby:
392                        launchedby=action
393                self._registerProcessProgress(action,searchFunction,launchedby)
394                aux_applist=searchFunction.execute_action(self.store,action,searchItem)
395                #1.- Get appstream metadata (faster)
396                partialAction='info'
397                applist=self._get_App_Info(aux_applist,launchedby)
398                self._debug("Add result for "+partialAction)
399                self.result[partialAction]=applist
400                #2.- Get rest of metadata (slower)
401                partialAction='pkginfo'
402                applist=self._get_Extended_App_Info(applist,launchedby,fullsearch)
403                realAction=action
404                if launchedby:
405                        realAction=launchedby
406                        self._debug("Assigned results of "+action+" to "+realAction)
407                if (len(applist)):
408                        self.result[realAction]=applist
409                        return_msg=True
410                else:
411                        notfound=''
412                        for item in searchItem:
413                                notfound=' '.join(searchItem)
414                        self.result[realAction]=[{notfound:" not found"}]
415                        return_msg=False
416                return(return_msg)
417        #def _search_Store
418
419        ####
420        #Install or remove an app
421        #Input:
422        #  - String with the app name
423        #Output:
424        #  - Result of the operation
425        ####
426        def _install_remove_App(self,appName,action='install',launchedby=None):
427                self._debug("Attempting to "+action +" "+appName)
428                result={}
429                return_msg=False
430                if (self._search_Store(appName,'search',False,action)):
431                        applistInfo=self.result[action]
432                        typeDict={}
433                        #Check if package is installed if we want to remove it or vice versa
434                        for appInfo in applistInfo:
435                                if (action=='install' and appInfo['status']=='installed') or (action=='remove' and appInfo['status']=='available'):
436                                        if action=='remove':
437                                                self.result[action]=[{appInfo['package']:"Package not installed"}]
438                                        else:
439                                                self.result[action]=[{appInfo['package']:"Package already installed"}]
440                                        return_msg=False
441                                        typeDict={}
442                                        break
443                               
444                                package_type=self._check_package_type(appInfo)
445                                if package_type in typeDict:
446                                        typeDict[package_type].append(appInfo)
447                                else:
448                                        typeDict[package_type]=[appInfo]
449
450                        for package_type in typeDict:
451                                self._debug("Checking plugin for "+action+ " "+package_type)
452                                if package_type in self.registeredPlugins[action]:
453                                        installFunction=self._execute_class_method(action,package_type,action)
454                                        result=installFunction.execute_action(action,typeDict[package_type])
455                                        self.result[action]=result
456                                        return_msg=True
457
458                return(return_msg)
459        #def install_App
460       
461        ####
462        #Check the package type
463        #Input:
464        # - AppInfo dict (element of list returned by _get_app_info)
465        #Output:
466        # - String with the type (deb, sh, zmd...)
467        ####
468        def _check_package_type(self,appInfo):
469                #Standalone installers must have the subcategory "installer"
470                #Zomandos must have the subcategory "Zomando"
471                self._debug("Checking package type for app "+appInfo['name'])
472                if "Zomando" in appInfo['categories']:
473                        return_msg="zmd"
474                else:
475                        if "Installer" in appInfo['categories']:
476                                return_msg="sh"
477                        else:
478                                return_msg="deb"
479                return(return_msg)
480        #def _check_package_type
Note: See TracBrowser for help on using the repository browser.