source: lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py @ 3277

Last change on this file since 3277 was 3277, checked in by Juanma, 3 years ago

wip on packaging

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