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

Last change on this file since 7170 was 7170, checked in by Juanma, 20 months ago

Add plugin automanage state status

File size: 21.6 KB
RevLine 
[3275]1#!/usr/bin/python3
2import sys
3import os
4import threading
5import syslog
[3286]6import pkgutil
[3277]7import lliurexstore.plugins as plugins
[3661]8import json
[3275]9######
10#Ver. 1.0 of storeManager.py
11# This class manages the store and the related plugins
12# It's implemented as an action-drived class.
13# There're four(five) main actions and each of them could execute and undeterminated number of subprocess in their respective thread
14# Each of these actions returns EVER a list of dictionaries.
15#####
16
[6645]17class StoreManager():
[6693]18        def __init__(self,*args,**kwargs):
[7170]19                self.dbg=False
[6645]20                if 'dbg' in kwargs.keys():
21                        self.dbg=kwargs['dbg']
22                self._propagate_dbg=False
[3275]23                self.store=None
[6645]24                self.related_actions={
[3275]25                                        'load':['load'],
[3656]26                                        'search':['search','get_info','pkginfo'],
27                                        'list':['list','get_info','pkginfo'],
28                                        'info':['list','get_info','pkginfo'],
[3275]29                                        'list_sections':['list_sections'],
[3656]30                                        'install':['search','get_info','pkginfo','install'],
31                                        'remove':['search','get_info','pkginfo','remove']
[3275]32                                        }
[6645]33                self.cli_mode=[]                        #List that controls cli_mode for plugins
[6693]34                self.threads={}                         #Dict with the functions that must execute each action
[6645]35                self.threads_progress={}                        #"" "" "" the progress for each launched thread
36                self.running_threads={}                 #"" "" "" the running threads
[6693]37                self.plugins_registered={}              #Dict with the relation between plugins and actions
38                self.register_action_progress={}                #Dict with the progress for each function/parent_action pair
[6645]39                self.action_progress={}                 #Progress of global actions based on average progress of individual processes
[6693]40                self.extra_actions={}           #Dict with the actions managed by plugins and no defined on the main class as related_actions
[3275]41                self.result={}                          #Result of the actions
42                self.lock=threading.Lock()              #locker for functions related to threads (get_progress, is_action_running...)
[6693]43                self.main(**kwargs)
[3275]44        #def __init__
45
[6693]46        def main(self,**kwargs):
[3646]47                self._define_functions_for_threads()    #Function that loads the dictionary self.threads
[6693]48                self.__init_plugins__(**kwargs)                 #Function that loads the plugins
[6645]49                self.execute_action('load')             #Initial load of the store
[3646]50        #def main
51
[3275]52        ####
53        #Load and register the plugins from plugin dir
54        ####
[6693]55        def __init_plugins__(self,**kwargs):
[3286]56                package=plugins
57                for importer, mod, ispkg in pkgutil.walk_packages(path=package.__path__, prefix=package.__name__+'.',onerror=lambda x: None):
[6693]58                        import_mod='from %s import *'%mod
[3286]59                        try:
[6693]60                                self._debug("Importing %s"%mod)
[6645]61                                exec (import_mod)
[3286]62                        except Exception as e:
[6693]63                                print("Import failed for %s"%mod)
64                                print("Reason; %s"%e)
[3286]65
[3275]66                for mod in (sys.modules.keys()):
67                        if 'plugins.' in mod:
[6645]68                                class_actions={}
69                                plugin_name_up=mod.split('.')[-1]
70                                plugin_name=plugin_name_up.lower()
[6693]71                                self._debug("Initializing %s"%plugin_name)
[6645]72                                sw_cli_mode=False
[3275]73                                try:
[6645]74                                        target_class=eval(plugin_name)()
75                                        class_actions=target_class.register()
76                                        if 'disabled' in target_class.__dict__.keys():
77                                                if target_class.disabled==True:
78                                                        self._debug("Disabling plugin %s"%plugin_name)
79                                                        continue
[7169]80                                                if target_class.disabled==None:
81                                                        self._debug("Plugin %s will manage its state"%plugin_name)
[6645]82                                                #Time to check if plugin is disabled or enabled by parm
83                                                #Values for the plugins_registered dict must be the same as the parm name that enables the plugin
[7169]84                                                else:
85                                                        for key,value in class_actions.items():
86                                                                val=value
87                                                                break
88                                                        if val in kwargs.keys():
89                                                                if kwargs[val]==True:
90                                                                        if target_class.disabled:
91                                                                                self._debug("Disabling plugin %s"%plugin_name)
92                                                                                continue
93                                                                else:
[6645]94                                                                        self._debug("Disabling plugin %s"%plugin_name)
95                                                                        continue
96                                                        else:
97                                                                self._debug("Disabling plugin %s"%plugin_name)
98                                                                continue
99                                        if 'cli_mode' in target_class.__dict__.keys():
[6693]100                                                if 'cli' in kwargs.keys():
[6645]101                                                        sw_cli_mode=True
102                                                        self._debug("Enabling cli mode for %s"%plugin_name)
[3275]103                                except Exception as e:
[6693]104                                        print ("Can't initialize %s %s"%(mod,target_class))
105                                        print ("Reason: %s"%e)
[3275]106                                        pass
107                       
[6645]108                                for action in class_actions.keys():
109                                        if action not in self.plugins_registered:
110                                                self.plugins_registered[action]={}
111                                        full_module_name='plugins.'+plugin_name_up+'.'+plugin_name
112                                        self.plugins_registered[action].update({class_actions[action]:full_module_name})
113                                        if sw_cli_mode:
114                                                self.cli_mode.append(full_module_name)
115
116                self._debug(str(self.plugins_registered))
[3275]117        #def __init_plugins__
118
[6645]119        def set_debug(self,dbg=True):
120                self.dbg=dbg
[3275]121                self._debug ("Debug enabled")
122        #def set_debug
123
124        def _debug(self,msg=''):
125                if self.dbg==1:
[6693]126                        print ('DEBUG Store: %s'%msg)
[3275]127        #def _debug
128
129        def _log(self,msg=None):
130                if msg:
131                        syslog.openlog('lliurex-store')
132                        syslog.syslog(msg)
[4363]133                        self._debug(msg)
[3275]134        ####
135        #dict of actions/related functions for threading
136        ####
137        def _define_functions_for_threads(self):
138                self.threads['load']="threading.Thread(target=self._load_Store)"
[6693]139                self.threads['get_info']="threading.Thread(target=self._get_App_Info,args=args,kwargs=kwargs)"
140                self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,args=args,kwargs=kwargs)"
141                self.threads['search']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
142                self.threads['list']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
143                self.threads['info']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
144                self.threads['install']='threading.Thread(target=self._install_remove_App,args=args,kwargs=kwargs)'
145                self.threads['remove']='threading.Thread(target=self._install_remove_App,args=args,kwargs=kwargs)'
146                self.threads['list_sections']='threading.Thread(target=self._list_sections,args=args,kwargs=kwargs)'
[3275]147        #def _define_functions_for_threads
148
149        ####
150        #Launch the appropiate threaded function for the desired action
151        #Input:
152        #  - action to be executed
153        #  - parms for the action
154        ####
[6693]155        def execute_action(self,action,*args,**kwargs):
156                #Action must be a kwarg but for retrocompatibility reasons we keep it as an arg
157                kwargs.update({"action":action})
158                self._debug("Launching action: %s with args %s and kwargs %s"%(action,args,kwargs))
[3275]159                if self.is_action_running('load'):
160                        self._join_action('load')
[6645]161                        self._debug("Resumed action %s"%action)
162                sw_track_status=False
[5187]163                if action not in self.threads.keys():
164                        #Attempt to add a new action managed by a plugin
[6693]165                        self._debug("Attempting to find a plugin for action %s"%action)
[6645]166                        if action in self.plugins_registered.keys():
167                                for package_type,plugin in self.plugins_registered[action].items():
168                                        self.action_progress[action]=0
[6693]169                                        self.threads[action]='threading.Thread(target=self._execute_class_method(action,package_type,action).execute_action,args=[action],kwargs={kwargs})'
[5187]170                                        break
[6693]171                                self._debug('Plugin for %s found: %s'%(action,self.plugins_registered[action]))
[6645]172                                self.related_actions.update({action:[action]})
173                                sw_track_status=True
[3275]174                if action in self.threads.keys():
175                        if self.is_action_running(action):
176                                #join thread if we're performing the same action
[6693]177                                self._debug("Waiting for current action %s to end"%s)
[6645]178                                self.running_threads[action].join()
[3275]179                        try:
[6645]180                                if action in self.action_progress.keys():
181                                        self.action_progress[action]=0
182                                self.action_progress[action]=0
[6458]183                                self.result[action]={}
[6645]184                                self.running_threads[action]=eval(self.threads[action])
185                                self.running_threads[action].start()
186                                if sw_track_status:
[5187]187                                        self.result[action]['status']={'status':0,'msg':''}
188                                else:
189                                        self.result[action]['status']={'status':-1,'msg':''}
[6693]190                                self._debug("Thread %s for action %s launched"%(self.running_threads[action],action))
[3653]191
[3275]192                        except Exception as e:
[6693]193                                self._debug("Can't launch thread for action: %s"%action)
194                                self._debug("Reason: %s"%e)
[3275]195                                pass
196                else:
[6693]197                        self._debug("No function associated with action %s"%action)
[3275]198        #def execute_action
199
200        ####
201        #Launch the appropiate class function
202        #Input:
203        #  - class action to be executed
204        #  - parms for the action
205        #  - parent action that demands the execution
206        #Output
207        #  - The class method to execute
208        ####
[6693]209        def _execute_class_method(self,action,package_type,*args,launchedby=None,**kwargs):
[6645]210                exe_function=None
[6693]211                if not package_type:
212                        package_type="*"
[6645]213                if action in self.plugins_registered:
[6693]214                        self._debug("Plugin for %s: %s"%(action,self.plugins_registered[action][package_type]))
215                        exe_function=eval(self.plugins_registered[action][package_type]+"("+','.join(args)+")")
[6458]216                        if self._propagate_dbg:
[6645]217                                exe_function.set_debug()
[6693]218                        if self.plugins_registered[action][package_type] in self.cli_mode:
[6645]219                                exe_function.cli_mode=True
220                        self._register_action_progress(action,exe_function,launchedby)
[3275]221                else:
[6693]222                        self._debug("No plugin for action: %s"%action)
223                if kwargs:
224                        self._debug("Parms: %s"%kwargs)
[6645]225                return (exe_function)
[3275]226        #def _execute_class_method
227
228        ###
229        #Tell if a a action is running
230        #Input:
231        #  - action to monitorize
232        #Output:
233        #  - status true/false
234        ###
[6645]235        def is_action_running(self,searched_action=None):
[3275]236                status=False
[6645]237                action_list=[]
238                if searched_action:
239                        action_list.append(searched_action)
[3823]240                else:
[6645]241                        action_list=self.related_actions.keys()
[3823]242
[6645]243                for action in action_list:
244                        if action in self.running_threads.keys():
245                                if self.running_threads[action].is_alive():
[3275]246                                        status=True
[3825]247                                        break
[3275]248                                else:
[6645]249                                        if action in self.related_actions.keys():
250                                                for related_action in self.related_actions[action]:
251                                                        if related_action in self.running_threads.keys():
252                                                                if self.running_threads[related_action].is_alive():
[3275]253                                                                        status=True
254                                                                        break
255                return(status)
256        #def is_action_running
257
258        ####
259        #Joins an action till finish
260        #Input:
261        #  - action to join
262        ####
263        def _join_action(self,action):
[6693]264                self._debug("Joining action: %s"%action)
[3275]265                try:
[6645]266                        self.running_threads[action].join()
[3275]267                except Exception as e:
[6693]268                        self._debug("Unable to join thread for: %s"%action)
269                        self._debug("Reason: %s"%e)
[3275]270                finally:               
[6645]271                        if action in self.running_threads.keys():
272                                del(self.running_threads[action])
[3275]273        #def _join_action
274
275        ####
[6645]276        #Register the method and action/parent_action pair in the progress dict
[3275]277        #Input:
278        #  - action launched
279        #  - function (a reference to the function)
[6645]280        #  - parent_action that owns the action (if any)
[3275]281        ####
[6645]282        def _register_action_progress(self,action,function,parent_action=None):
283                if action in self.register_action_progress.keys():
[6693]284                        self._debug("Appended process for action: %s and function: %s"%(action,function))
[6645]285                        self.register_action_progress[action].append(function)
[3275]286                else:
[6693]287                        self._debug("Registered process for action: %s and function %s"%(action,function))
[6645]288                        self.register_action_progress[action]=[function]
289                if parent_action:
[6693]290                        self._debug("Registered process for Parent Action: %s-%s and function: %s"%(action,parent_action,function))
[6645]291                        if parent_action in self.threads_progress.keys():
292                                self.threads_progress[parent_action].update({action:function})
[3275]293                        else:
[6645]294                                self.threads_progress[parent_action]={action:function}
295        #def _register_action_progress
[3275]296
297        ####
298        #Get the progress of the executed actions
299        #Input
300        #  - action or none if we want all of the progress
301        #Output:
302        #  - Dict of results indexed by actions
303        ####
304        def get_progress(self,action=None):
305                progress={'search':0,'list':0,'install':0,'remove':0,'load':0,'list_sections':0}
[6645]306                action_list=[]
[6693]307                if action in self.register_action_progress.keys():
[6645]308                        action_list=[action]
[3275]309                else:
[6645]310                        action_list=self.register_action_progress.keys()
[3275]311                self.lock.acquire() #prevent that any thread attempts to change the iterator
[6645]312                for parent_action in self.related_actions.keys():
313                        if self.is_action_running(parent_action):
314                                for action in action_list:
315                                        if parent_action in self.threads_progress.keys():
316                                                acum_progress=0
317                                                for threadfunction,function in self.threads_progress[parent_action].items():
318                                                        acum_progress=acum_progress+function.progress
[3275]319       
[6645]320                                                count=len(self.related_actions[parent_action])
321                                                self.action_progress[parent_action]=round(acum_progress/count,0)
322                                                progress[parent_action]=self.action_progress[parent_action]
[3275]323                        else:
324                                #put a 100% just in case
[6645]325                                if parent_action in self.action_progress.keys():
326                                        self.action_progress[parent_action]=100
[3275]327                self.lock.release()
[6645]328                return(self.action_progress)
[3275]329        #def get_progress
330
331        ####
332        #Gets the result of an action
333        #Input:
334        #  - action
335        #Output:
336        #  - Dict of results indexed by actions
337        ####
338        def get_result(self,action=None):
339                self.lock.acquire() #Prevent changes on results from threads
340                result={}
341                if action==None:
[3653]342                        for res in self.result.keys():
343                                if res!='load':
[4363]344                                        if 'data' in self.result[res]:
345                                                result[res]=self.result[res]['data']
346                                        else:
347                                                result[res]=[]
[3275]348                else:
[6693]349                        self._debug("Checking result for action %s"%action)
[3275]350                        if self.is_action_running(action):
351                                self._join_action(action)
352                        result[action]=None
353                        if action in self.result:
[4363]354                                if 'data' in self.result[action]:
355                                        result[action]=self.result[action]['data']
356                                else:
357                                        result[action]=[]
[3275]358                self.lock.release()
[6645]359                if action in self.extra_actions.keys():
[5187]360                        self._load_Store()
[3275]361                return(result)
362        #def get_result
363
364        ####
[3653]365        #Gets the status of an action
366        #Input.
367        # - action
368        #Output:
369        # - Status dict of the action
370        ####
371        def get_status(self,action=None):
372                self.lock.acquire()
[6693]373                self._debug("Checking status for action %s"%action)
[3653]374                result={}
375                if action in self.result:
376                        result=self.result[action]['status']
[5133]377                        try:
[6645]378                                err_file=open('/usr/share/lliurex-store/files/error.json').read()
379                                err_codes=json.loads(err_file)
380                                err_code=str(result['status'])
381                                if err_code in err_codes:
382                                        result['msg']=err_codes[err_code]
[5133]383                                else:
384                                        result['msg']=u"Unknown error"
385                        except:
386                                        result['msg']=u"Unknown error"
[3653]387                self.lock.release()
388                return(result)
389        #def get_status
390
391        ####
[3275]392        #Loads the store
393        ####
394        def _load_Store(self):
[6645]395                action='load'
396                for package_type in self.plugins_registered[action]:
[7143]397                        load_function=self._execute_class_method(action,package_type,launchedby=None)
398                        self.store=load_function.execute_action(action=action,store=self.store)['data']
[3275]399        #def _load_Store
400
401        ####
402        #Loads the info related to one app
403        #Input:
404        #  - List of App objects
405        #Output:
406        #  - Dict with the related info
407        ####
408        def _get_App_Info(self,applist,launchedby=None):
[3656]409                action='get_info'
[6693]410                info_function=self._execute_class_method(action,None,launchedby=launchedby)
[6645]411                info_applist=info_function.execute_action(self.store,action,applist)
412                return(info_applist)
[3275]413        #def _get_App_Info
414
415        ####
416        #Loads the extended info related to one app (slower)
417        #Input:
418        #  - Dict off Apps (as returned by _get_app_info)
419        #Output:
420        #  - Dict with the related info
421        ####
[7143]422        def _get_Extended_App_Info(self,info_applist,launchedby=None,fullsearch=True):
[3275]423                #Check if there's any plugin for the distinct type of packages
424                action='pkginfo'
[6645]425                types_dict={}
[4363]426                result={}
427                result['data']=[]
428                result['status']={'status':0,'msg':''}
[6645]429                for app_info in info_applist:
[7143]430                        package_type=self._check_package_type(app_info)
431                        if package_type in types_dict:
432                                types_dict[package_type].append(app_info)
[7120]433                        else:
[7143]434                                types_dict[package_type]=[app_info]
[6645]435                for package_type in types_dict:
[6693]436                        self._debug("Checking plugin for %s %s"%(action,package_type))
[6645]437                        if package_type in self.plugins_registered[action]:
[7143]438                                #Only search full info if it's required
[4749]439                                if (fullsearch==False and package_type=='deb'):
[6645]440                                        result['data'].extend(types_dict[package_type])
[3275]441                                        continue
[6693]442                                self._debug("Retrieving info for %s"%types_dict[package_type])
443                                info_function=self._execute_class_method(action,package_type,launchedby=launchedby)
[6645]444                                result['data'].extend(info_function.execute_action(action,types_dict[package_type])['data'])
[5133]445                        else:
[6645]446                                result['data'].append(app_info)
[3852]447                return(result)
[3275]448        #def _get_Extended_App_Info
449
450        def _list_sections(self,searchItem='',action='list_sections',launchedby=None):
451                result={}
452                self._debug("Retrieving all sections")
[3653]453                data={}
454                status={}
[6645]455                if action in self.plugins_registered.keys():
[6693]456                        self._debug("Plugin for generic search: %s"%self.plugins_registered[action]['*'])
[6645]457                        finder=self.plugins_registered[action][('*')]
458                        search_function=eval(finder+"()")
459                        result=search_function.execute_action(self.store,action,searchItem)
[3653]460                        status=result['status']
461                        data=result['data']
[3275]462                else:
[6693]463                        print("No plugin for action %s"%action)
[3653]464                self.result[action]['data']=data
465                self.result[action]['status']=status
[6693]466                self._debug("Sections: %s"%self.result[action]['data'])
467                self._debug("Status: %s"%self.result[action]['status'])
[3275]468
469        ####
470        #Search the store
471        #Input:
472        #  - string search
473        #Output:
474        #  - List of dicts with all the info
475        ####
[6693]476        def _search_Store(self,*args,**kwargs):
477                search_item=args[0]
478                action='search'
479                if 'action' in kwargs.keys():
480                        action=kwargs['action']
481                launchedby=None
482                if 'launchedby' in kwargs.keys():
483                        launchedby=kwargs['launchedby']
484                max_results=0
485                if 'max_results' in kwargs.keys():
486                        max_results=kwargs['max_results'] 
487                fullsearch=False
488                if 'fullsearch' in kwargs.keys():
489                        fullsearch=kwargs['fullsearch']
[3839]490                result={}
[6693]491                tmp_applist=[]
492                if action=='list_sections':
[6645]493                        search_item=''
[3656]494                elif action=='info':
495                        fullsearch=True
[3275]496                if not launchedby:
497                        launchedby=action
[3852]498                #Set the exact match to false for search method
499                exact_match=True
500                if (launchedby=='search'):
501                                exact_match=False
[6645]502                for package_type in self.plugins_registered[action]:
[6693]503                        search_function=self._execute_class_method(action,'*',launchedby=launchedby)
[6645]504                        result.update(search_function.execute_action(self.store,action,search_item,exact_match,max_results))
[6693]505                tmp_applist=result['data']
[4363]506                status=result['status']
[3653]507                realAction=action
508                if status['status']==0:
[3646]509                        #1.- Get appstream metadata (faster)
[6645]510                        subordinate_action='get_info'
511                        self.result[subordinate_action]={}
[6693]512                        result=self._get_App_Info(tmp_applist,launchedby)
513                        self._debug("Add result for %s"%subordinate_action)
[6645]514                        self.result[subordinate_action]=result
[3646]515                        #2.- Get rest of metadata (slower)
[6645]516                        subordinate_action='pkginfo'
[7143]517                        result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch)
[3646]518                        if launchedby:
519                                realAction=launchedby
[6693]520                                self._debug("Assigned results of %s to %s"%(action,realAction))
[4363]521                        if (result['status']['status']==0) or (result['status']['status']==9):
[3646]522                                return_msg=True
[4363]523                                if fullsearch:
524                                        result['status']['status']=0
[3646]525                        else:
526                                return_msg=False
[3275]527                else:
528                        return_msg=False
[4363]529                self.result[launchedby]['data']=result['data']
530                self.result[launchedby]['status']=result['status']
[3275]531                return(return_msg)
532        #def _search_Store
533
534        ####
535        #Install or remove an app
536        #Input:
537        #  - String with the app name
538        #Output:
539        #  - Result of the operation
540        ####
[6693]541        def _install_remove_App(self,*args,**kwargs):
542                appName=args[0]
543                if 'action' in kwargs.keys():
544                        action=kwargs['action']
545                self._log("Attempting to %s %s"%(action,appName))
[3275]546                result={}
547                return_msg=False
[6693]548                if (self._search_Store(appName,action='search',fullsearch=True,launchedby=action)):
[6645]549                        info_applist=self.result[action]['data']
550                        types_dict={}
[3275]551                        #Check if package is installed if we want to remove it or vice versa
[6645]552                        for app_info in info_applist:
[6693]553                        #Appstream doesn't get the right status in all cases so we rely on the mechanisms given by the different plugins.
[6645]554                                if (action=='install' and app_info['state']=='installed') or (action=='remove' and app_info['state']=='available'):
555                                        if (action=='remove' and app_info['state']=='available'):
556                                                        self.result[action]['status']={app_info['package']:3}
[5216]557                                                        self.result[action]['status']={'status':3}
558                                        else:
[6645]559                                                self.result[action]['status']={app_info['package']:4}
[5216]560                                                self.result[action]['status']={'status':4}
561                                                pass
562                                        return_msg=False
[6645]563                                        types_dict={}
[5216]564                                        break
[3275]565                               
[6645]566                                package_type=self._check_package_type(app_info)
567                                if package_type in types_dict:
568                                        types_dict[package_type].append(app_info)
[3275]569                                else:
[6645]570                                        types_dict[package_type]=[app_info]
[3275]571
[6645]572                        for package_type in types_dict:
[6693]573                                self._debug("Checking plugin for %s %s"%(action,package_type))
[6645]574                                if package_type in self.plugins_registered[action]:
[6693]575                                        install_function=self._execute_class_method(action,package_type,launchedby=action)
[4749]576                                        if package_type=='zmd':
577                                        #If it's a zmd the zomando must be present in the system
[6645]578                                                zmd_info=[]
579                                                for zmd_bundle in types_dict[package_type]:
[4749]580                                                        zmdInfo={}
[6693]581                                                        self._debug("Cheking presence of zmd %s"%zmd_bundle['package'])
[6645]582                                                        zmd='/usr/share/zero-center/zmds/'+app_info['package']+'.zmd'
[4749]583                                                        if not os.path.exists(zmd):
[6645]584                                                                zmdInfo['package']=zmd_bundle['package']
585                                                                zmd_info.append(zmdInfo)
586                                                if zmd_info:
[4749]587                                                        self._debug("Installing needed packages")
[6693]588                                                        install_depends_function=self._execute_class_method(action,"deb",launchedby=action)
[6645]589                                                        result=install_depends_function.execute_action(action,zmd_info)
[4749]590                                                       
[6645]591                                        result=install_function.execute_action(action,types_dict[package_type])
[3275]592                                        self.result[action]=result
[5215]593                                        if result['status']['status']==0:
594                                                #Mark the apps as installed or available
[6645]595                                                for app in types_dict[package_type]:
[5215]596                                                        if action=='install':
597                                                                app['appstream_id'].set_state(1)
598                                                                self._debug("App state changed to installed")
599                                                        else:
600                                                                app['appstream_id'].set_state(2)
601                                                                self._debug("App state changed to available")
[3275]602                                        return_msg=True
[6693]603                self._log("Result %s: %s"%(action,self.result[action]))
[3275]604                return(return_msg)
605        #def install_App
606       
607        ####
608        #Check the package type
609        #Input:
610        # - AppInfo dict (element of the list returned by _get_app_info)
611        #Output:
612        # - String with the type (deb, sh, zmd...)
613        ####
[6645]614        def _check_package_type(self,app_info):
[3275]615                #Standalone installers must have the subcategory "installer"
616                #Zomandos must have the subcategory "Zomando"
[6645]617                self._debug("Checking package type for app "+app_info['name'])
618                if "Zomando" in app_info['categories']:
[7143]619                        return_msg="zmd"
620                else:
[7119]621                #Standalone installers must have an installerUrl field loaded from a bundle type=script description
[7143]622                        if app_info['bundle']!='':
623                                return_msg=app_info['bundle']
624                        elif app_info['installerUrl']!='':
625                                return_msg="sh"
626                        else:
627                                return_msg="deb"
[3275]628                return(return_msg)
629        #def _check_package_type
Note: See TracBrowser for help on using the repository browser.