Changeset 6693


Ignore:
Timestamp:
Jan 25, 2018, 4:47:53 PM (19 months ago)
Author:
Juanma
Message:

Add snap support. Improved argument pass for plugins

Location:
lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/appImageManager.py

    r6645 r6693  
    2020                self.progress=0
    2121                self.partial_progress=0
    22                 #This dict defines wich package_type relies on what action
    23                 #action=example
    24                 #package='*' (in this case all packages)
    2522                self.plugin_actions={'install':'appimage','remove':'appimage','pkginfo':'appimage','load':'appimage'}
    2623                self.result={}
     
    8986        #def _set_status
    9087
    91         def _callback(self,partialSize=0,totalSize=0):
     88        def _callback(self,partial_size=0,total_size=0):
    9289                limit=99
    93                 if partialSize!=0 and totalSize!=0:
    94                         inc=round(partialSize/totalSize,2)*100
     90                if partial_size!=0 and total_size!=0:
     91                        inc=round(partial_size/total_size,2)*100
    9592                        self.progress=inc
    9693                else:
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py

    r6645 r6693  
    77                self.installer=''
    88                self.dbg=False
    9                 self.pkgList=[]
    109                self.result=[]
    1110                self.progress=0
     
    3837
    3938        def execute_action(self,action,applist):
    40                 self._debug("Applist: "+str(applist))
    4139                self.progress=0
    4240                self.installer=packagekit.Client()
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/infoManager.py

    r6645 r6693  
    33class infomanager:
    44        def __init__(self):
    5                 self.dbg=True
    6                 self.pluginInfo={'get_info':'*'}
    7 #               self.pluginInfo={'info':'*','get_info':'*'}
     5                self.dbg=False
     6                self.plugin_actions={'get_info':'*'}
    87                self.result={}
    98                self.result['status']={'status':-1,'msg':''}
     
    2524
    2625        def register(self):
    27                 return(self.pluginInfo)
     26                return(self.plugin_actions)
    2827        #def register
    2928
     
    103102                                                        break
    104103                                        else:
    105                                                 #If there's no icon set empty icon path
    106                                                 appInfo['icon']=""
    107 #                               if app.get_icon_default():
    108 #                                       appInfo['icon']=appInfo['icon']+'/'+app.get_icon_default().get_name()
     104                                                appInfo['icon']=''
    109105                               
    110106                        if app.get_screenshots():       
     
    153149                                if 'embed' not in appInfo['video']:
    154150                                        appInfo['video']=appInfo['video'].replace('watch?v=','embed/')
    155                         #F***g appstream returns unknown for all the possible types
     151                        #F***g appstream returns unknown for all the possible kinds
    156152#                       if app.get_bundle_default():
    157153#                               appInfo['bundle']=app.get_bundle_default().get_kind()
    158                         #Fix F***g appstream returns unknown for all the possible types
     154                        #Fix F***g appstream returns unknown for all the possible kinds
    159155                        #ID must contain bundle type as last field
    160156                        for bundle in app.get_bundles():
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/loadStore.py

    r6645 r6693  
    5252                if action=='load_bundles':
    5353                        self._load_store(self.store,loadBundles=True)
    54 #               self.progress=100
    5554                self.result['data']=self.store
    5655                self.progress=100
    5756                return(self.result)
    58 #               return (self.store)
    5957        #def execute_action
    6058
     
    9189                        if target_file.endswith('appdata.xml'):
    9290                                store_file=Gio.File.new_for_path(target_dir+'/'+target_file)
    93                                 self._debug("Adding file "+target_dir+'/'+target_file)
     91                                self._debug("Adding file %s/%s"%(target_dir,target_file))
    9492                                try:
    9593                                        store.from_file(store_file,icon_dir,None)
    9694                                except Exception as e:
    97                                         self._debug("Couldn't add file "+target_file+" to store")
    98                                         self._debug("Reason: "+str(e))
     95                                        self._debug("Couldn't add file %s to store"%target_file)
     96                                        self._debug("Reason: %s"%e)
    9997                return(store)
    10098       
     
    111109                                                a.remove_veto(veto)
    112110                                        store.add_app(a)
    113                                         self._debug("Adding app from desktop "+desktop_file)
     111                                        self._debug("Adding app from desktop %s"%desktop_file)
    114112                                except:
    115113                                        pass
     
    125123                        #Zomandos get max priority
    126124                        if app.has_category('Zomando'):
    127                                 self._debug("Prioritize zmd "+str(app.get_id()))
     125                                self._debug("Prioritize zmd %s"%app.get_id())
    128126                                app.set_priority(400)
    129127                                lliurex_apps.update({app.get_id_filename():app})
     
    132130                        #Prioritize Lliurex apps
    133131                        elif app.has_category('Lliurex'):
    134                                 self._debug("Prioritize app "+str(app.get_id()))
     132                                self._debug("Prioritize app %s"%app.get_id())
    135133                                app.set_priority(200)
    136134                                lliurex_apps.update({app.get_id_filename():app})
    137135                        elif str(app.get_origin()).find('lliurex')>=0:
    138                                 self._debug("Prioritize app "+app.get_id())
     136                                self._debug("Prioritize app %s"%app.get_id())
    139137                                app.set_priority(100)
    140138                                lliurex_apps.update({app.get_id_filename():app})
     
    142140                                app.set_priority(0)
    143141                                if app.get_id_filename() in lliurex_apps.keys():
    144                                         self._debug("Mergin app "+str(app.get_id())+" as is in Lliurex")
     142                                        self._debug("Mergin app %s as is in LliureX"%app.get_id())
    145143                                        lliurex_apps[app.get_id_filename()].subsume_full(app,appstream.AppSubsumeFlags.BOTH_WAYS)
    146144                                        store.remove_app(app)
     
    150148                        #Remove add-on apps (as are included in the main packages)
    151149                        if app.get_kind()==appstream.AppKind.ADDON:
    152                                 self._debug("Removed addon "+str(app.get_pkgnames()))
     150                                self._debug("Removed addon %s"%app.get_pkgnames())
    153151                                store.remove_app(app)
    154152                        #Remove duplicated apps
     
    157155                        if pkg in tmp_store_apps.keys():
    158156                                fn=app.get_id_no_prefix()
    159                                 self._debug("Comparing "+fn+" with "+tmp_store_apps[pkg]['fn'])
     157                                self._debug("Comparing %s with %s"%(fn,tmp_store_apps[pkg]['fn']))
    160158                                if fn != tmp_store_apps[pkg]['fn']:
    161159                                        if fn != pkg and ".desktop" not in fn:
    162                                                 self._debug("Removed duplicated "+app.get_id())
     160                                                self._debug("Removed duplicated %s"%app.get_id())
    163161                                                store.remove_app(app)
    164162                                        else:
    165                                                 self._debug("Removed duplicated "+tmp_store_apps[pkg]['app'].get_id())
     163                                                self._debug("Removed duplicated %s"%tmp_store_apps[pkg]['app'].get_id())
    166164                                                store.remove_app(tmp_store_apps[pkg]['app'])
    167165                                                tmp_store_apps.update({pkg:{'fn':app.get_id_no_prefix(),'app':app}})
     
    178176        def _purge_zomandos(self,zmd_apps,store):
    179177                for zmd_id in zmd_apps:
    180                         self._debug("Searching debs related to "+zmd_id)
     178                        self._debug("Searching debs related to %s"%zmd_id)
    181179                        purge_list=store.get_apps_by_id(zmd_id)
    182180                        purge_list.extend(store.get_apps_by_id(zmd_id+".desktop"))
     
    184182                                if purge_app:
    185183                                        if not purge_app.has_category('Zomando'):
    186                                                 self._debug("Removed related zomando app "+str(purge_app.get_id()))
     184                                                self._debug("Removed related zomando app %s"%purge_app.get_id())
    187185                                                store.remove_app(purge_app)
    188186                return(store)
     
    222220                                                        store.remove_app(app)
    223221                                                else:
    224                                                         self._debug("App "+blacklist_app+" from blacklist not found in store. Assigned to RE blacklist")
     222                                                        self._debug("App %s from blacklist not found in store. Assigned to RE blacklist"%blacklist_app)
    225223                                                        blacklist_re.append("("+blacklist_app+")")
    226224                                if blacklist_re:
     
    231229                                                        if re_result:
    232230                                                                store.remove_app(app)
    233                                                                 self._debug("Removed "+str(app.get_id()) +" as matches with "+blacklist_app)
     231                                                                self._debug("Removed %s as matches with %s"%(app.get_id(),blacklist_app))
    234232                        else:
    235233                                self._debug('No blacklist to check')
    236234                except Exception as e:
    237                         self._debug("Error processing blacklist: "+str(e))
     235                        self._debug("Error processing blacklist: %s"%e)
    238236                finally:
    239237                        return(store)
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/searchManager.py

    r6645 r6693  
    2121                return (self.applist)
    2222
    23         def set_debug(self,dbg):
     23        def set_debug(self,dbg=True):
    2424                self.dbg=dbg
    2525                self._debug ("Debug enabled")
     
    3535
    3636        def execute_action(self,appstreamStore,action,tokens,exact_match_for_search=False,max_results=0):
     37                self._debug("Executing action %s"%action)
     38                self._debug("Tokens: %s"%tokens)
    3739                self.progress=0
    38                 if not type(tokens) is str:
     40                if type(tokens)==type([]):
     41                        tokens=' '.join(tokens)
     42                if type(tokens) is str:
     43                        tokens=tokens.lower()
     44                else:
    3945                        tokens=''
    40                 else:
    41                         tokens=tokens.lower()
    4246                if len(tokens.split(' '))>1:
    4347                        if action=='search':
     
    7579                applist=[]
    7680                app=None
    77                 if len(tokens)==1:
     81#               if len(tokens)==1:
     82                if exact_match:
    7883                        app=self._app_exists(tokens[0])
    7984                if app:
     
    149154                                                applist_2.append(app)
    150155                                        else:
    151                                                 print("*************")
    152156                                                print("Removing %s"%app.get_pkgname())
    153                                                 print("*************")
    154157                        applist=applist_2
    155158#                       for app in applist:
     
    202205                                                score=app.search_matches(token)
    203206                                                if score>=self.precision:
    204                                                         if "appimage" in app.get_id().lower():
    205                                                                 score=1
     207#                                                       if "appimage" in app.get_id().lower():
     208#                                                               score=1
    206209                                                        if score in tmp_app_dict:
    207210                                                                tmp_app_dict[score].append(app)
    208211                                                        else:
    209212                                                                tmp_app_dict[score]=[app]
    210                         for match in sorted(tmp_app_dict):
     213                        fake_app=[]
     214                        for match in sorted(tmp_app_dict.keys()):
    211215                                for app in tmp_app_dict[match]:
    212216                                        if app not in applist:
    213217                                                self._debug("Adding app "+app.get_id() + " with score: "+str(match))
    214                                                 applist.insert(1,app)
     218                                                applist.insert(0,app)
    215219                return(applist)
    216220
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/shManager.py

    r6645 r6693  
    2121        #def __init__
    2222
    23         def set_debug(self,dbg):
     23        def set_debug(self,dbg=True):
    2424                self.dbg=dbg
    2525                self._debug ("Debug enabled")
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/snapManager.py

    r6645 r6693  
    101101
    102102        def _load_snap_store(self,store):
    103                 try:
    104                         for pkg in self._search_snap("*"):
    105                                 store.add_app(self._generate_appstream_app(pkg))
    106                 except:
    107                         self._set_status(1)
     103                pkgs=[]
     104                if self.cli_mode:
     105                        pkgs=self._search_snap("*")
     106                else:
     107                        pkgs=self._search_snap_async("*")
     108                self._set_status(1)
     109                for pkg in pkgs:
     110                        store.add_app(self._generate_appstream_app(pkg))
    108111                return(store)
    109112
     
    148151                                                        None,
    149152                                                        self._search_cb,(None,),None)
    150                 time.sleep(0.5)
     153                while 'Snapd' not in str(type(wrap)):
     154                        time.sleep(0.1)
    151155                snaps=self.snap_client.find_finish(wrap)
    152156                if type(snaps)!=type([]):
     
    154158                else:
    155159                        pkgs=snaps
    156                 return(pkgs)
     160                stable_pkgs=[]
     161                for pkg in pkgs:
     162                        if pkg.get_channel()=='stable':
     163                                stable_pkgs.append(pkg)
     164                return(stable_pkgs)
    157165
    158166        def _search_snap(self,tokens):
     
    160168                pkg=None
    161169                try:
    162                         pkg=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None,None)
     170                        pkgs=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None,None)
    163171                except Exception as e:
    164172                        print(e)
    165173                        self._set_status(1)
     174                stable_pkgs=[]
     175                for pkg in pkgs:
     176                        if pkg.get_channel()=='stable':
     177                                stable_pkgs.append(pkg)
    166178                self._debug("Done")
    167                 return(pkg)
     179                return(stable_pkgs)
    168180        #def _search_snap
    169181
     
    193205        def _get_info(self,app_info):
    194206                #switch to launch async method when running under a gui
    195                 #For an unknown request will block when sync mode under a gui
     207                #For an unknown reason request will block when sync mode under a gui and async blocks when on cli (really funny)
    196208                if self.cli_mode:
    197209                        pkgs=self._search_snap(app_info['name'])
     
    223235                                                screenshot_list.append(screen.get_url())
    224236                                        app_info["screenshots"]=screenshot_list
    225                                 print (pkg.get_channel())
    226237                                #Method not working in xenial, license default type assigned in infoManager
    227238#                               if pkg.get_license():
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/zmdManager.py

    r6645 r6693  
    7373        def _set_status(self,status,msg=''):
    7474                self.result['status']={'status':status,'msg':msg}
    75 #               dataList['status']={'status':status,'msg':msg}
    7675       
    7776        def _callback(self,zmd_launcher):
     
    9695                                err=0
    9796                                try:
    98 #                                       zmd_sudo=['gksudo',zmd]
    9997                                        zmd_sudo=['pe',zmd]
    10098                                        self._debug("executing "+str(zmd_sudo))
     
    202200                except Exception as e:
    203201                        self._set_status(10)
    204 #               self.result['data'].append(app_info)
    205 #               self.result.append(app_info)
    206202                return(app_info)
    207203        #def _get_Zmd_Info
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py

    r6645 r6693  
    1616
    1717class StoreManager():
    18 #       def __init__(self,snap=False,appimage=False,dbg=False):
    19         def __init__(self,**kwargs):
     18        def __init__(self,*args,**kwargs):
    2019                self.dbg=False
    2120                if 'dbg' in kwargs.keys():
     
    3332                                        }
    3433                self.cli_mode=[]                        #List that controls cli_mode for plugins
    35                 self.threads={}                         #Dict that stores the functions that must execute each action
     34                self.threads={}                         #Dict with the functions that must execute each action
    3635                self.threads_progress={}                        #"" "" "" the progress for each launched thread
    3736                self.running_threads={}                 #"" "" "" the running threads
    38                 self.plugins_registered={}              #Dict that have the relation between plugins and actions
    39                 self.register_action_progress={}                #Dict that stores the progress for each function/parent_action pair
     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
    4039                self.action_progress={}                 #Progress of global actions based on average progress of individual processes
    41                 self.extra_actions={}           #Dict that have the actions managed by plugins and no defined on the main class as related_actions
     40                self.extra_actions={}           #Dict with the actions managed by plugins and no defined on the main class as related_actions
    4241                self.result={}                          #Result of the actions
    4342                self.lock=threading.Lock()              #locker for functions related to threads (get_progress, is_action_running...)
    44                 self.main(kwargs)
     43                self.main(**kwargs)
    4544        #def __init__
    4645
    47         def main(self,args={}):
     46        def main(self,**kwargs):
    4847                self._define_functions_for_threads()    #Function that loads the dictionary self.threads
    49                 self.__init_plugins__(args)                     #Function that loads the plugins
     48                self.__init_plugins__(**kwargs)                 #Function that loads the plugins
    5049                self.execute_action('load')             #Initial load of the store
    5150        #def main
     
    5453        #Load and register the plugins from plugin dir
    5554        ####
    56         def __init_plugins__(self,args={}):
     55        def __init_plugins__(self,**kwargs):
    5756                package=plugins
    5857                for importer, mod, ispkg in pkgutil.walk_packages(path=package.__path__, prefix=package.__name__+'.',onerror=lambda x: None):
    59                         import_mod='from '+mod+' import *'
     58                        import_mod='from %s import *'%mod
    6059                        try:
    61                                 self._debug("Importing "+str(mod))
     60                                self._debug("Importing %s"%mod)
    6261                                exec (import_mod)
    6362                        except Exception as e:
    64                                 print(str(e))
     63                                print("Import failed for %s"%mod)
     64                                print("Reason; %s"%e)
    6565
    6666                for mod in (sys.modules.keys()):
     
    6969                                plugin_name_up=mod.split('.')[-1]
    7070                                plugin_name=plugin_name_up.lower()
    71                                 self._debug("Initializing "+str(plugin_name))
     71                                self._debug("Initializing %s"%plugin_name)
    7272                                sw_cli_mode=False
    7373                                try:
     
    8383                                                        val=value
    8484                                                        break
    85                                                 if val in args.keys():
    86                                                         if args[val]==True:
     85                                                if val in kwargs.keys():
     86                                                        if kwargs[val]==True:
    8787                                                                if target_class.disabled:
    8888                                                                        self._debug("Disabling plugin %s"%plugin_name)
     
    9595                                                        continue
    9696                                        if 'cli_mode' in target_class.__dict__.keys():
    97                                                 if 'cli' in args.keys():
     97                                                if 'cli' in kwargs.keys():
    9898                                                        sw_cli_mode=True
    9999                                                        self._debug("Enabling cli mode for %s"%plugin_name)
    100100                                except Exception as e:
    101                                         print ("Can't initialize "+str(mod)+' '+str(target_class))
    102                                         print ("Reason: "+str(e))
     101                                        print ("Can't initialize %s %s"%(mod,target_class))
     102                                        print ("Reason: %s"%e)
    103103                                        pass
    104104                       
     
    121121        def _debug(self,msg=''):
    122122                if self.dbg==1:
    123                         print ('DEBUG Store: '+msg)
     123                        print ('DEBUG Store: %s'%msg)
    124124        #def _debug
    125125
     
    134134        def _define_functions_for_threads(self):
    135135                self.threads['load']="threading.Thread(target=self._load_Store)"
    136 #               self.threads['load_bundles']="threading.Thread(target=self._load_Store)"
    137                 self.threads['get_info']="threading.Thread(target=self._get_App_Info,args=[args])"
    138                 self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,args=[args])"
    139                 self.threads['search']='threading.Thread(target=self._search_Store,args=[args,action])'
    140                 self.threads['list']='threading.Thread(target=self._search_Store,args=[args,action])'
    141                 self.threads['info']='threading.Thread(target=self._search_Store,args=[args,action])'
    142                 self.threads['install']='threading.Thread(target=self._install_remove_App,args=[args,action])'
    143                 self.threads['remove']='threading.Thread(target=self._install_remove_App,args=[args,action])'
    144                 self.threads['list_sections']='threading.Thread(target=self._list_sections,args=[args,action])'
     136                self.threads['get_info']="threading.Thread(target=self._get_App_Info,args=args,kwargs=kwargs)"
     137                self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,args=args,kwargs=kwargs)"
     138                self.threads['search']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
     139                self.threads['list']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
     140                self.threads['info']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
     141                self.threads['install']='threading.Thread(target=self._install_remove_App,args=args,kwargs=kwargs)'
     142                self.threads['remove']='threading.Thread(target=self._install_remove_App,args=args,kwargs=kwargs)'
     143                self.threads['list_sections']='threading.Thread(target=self._list_sections,args=args,kwargs=kwargs)'
    145144        #def _define_functions_for_threads
    146145
     
    151150        #  - parms for the action
    152151        ####
    153         def execute_action(self,action,args=None):
    154                 self._debug("Launching action: "+action+" and args "+str(args))
     152        def execute_action(self,action,*args,**kwargs):
     153                #Action must be a kwarg but for retrocompatibility reasons we keep it as an arg
     154                kwargs.update({"action":action})
     155                self._debug("Launching action: %s with args %s and kwargs %s"%(action,args,kwargs))
    155156                if self.is_action_running('load'):
    156157                        self._join_action('load')
     
    159160                if action not in self.threads.keys():
    160161                        #Attempt to add a new action managed by a plugin
    161                         self._debug("Attempting to find a plugin for action "+action)
     162                        self._debug("Attempting to find a plugin for action %s"%action)
    162163                        if action in self.plugins_registered.keys():
    163164                                for package_type,plugin in self.plugins_registered[action].items():
    164165                                        self.action_progress[action]=0
    165                                         self.threads[action]='threading.Thread(target=self._execute_class_method(action,package_type,action).execute_action,args=[action])'
     166                                        self.threads[action]='threading.Thread(target=self._execute_class_method(action,package_type,action).execute_action,args=[action],kwargs={kwargs})'
    166167                                        break
    167                                 self._debug('Plugin for '+action+' found: '+str(self.plugins_registered[action]))
     168                                self._debug('Plugin for %s found: %s'%(action,self.plugins_registered[action]))
    168169                                self.related_actions.update({action:[action]})
    169170                                sw_track_status=True
     
    171172                        if self.is_action_running(action):
    172173                                #join thread if we're performing the same action
    173                                 self._debug("Waiting for current action "+action+" to end")
     174                                self._debug("Waiting for current action %s to end"%s)
    174175                                self.running_threads[action].join()
    175176                        try:
     
    184185                                else:
    185186                                        self.result[action]['status']={'status':-1,'msg':''}
    186                                 self._debug("Thread "+str(self.running_threads[action])+" for action "+action+" launched")
     187                                self._debug("Thread %s for action %s launched"%(self.running_threads[action],action))
    187188
    188189                        except Exception as e:
    189                                 self._debug("Can't launch thread for action: "+action)
    190                                 self._debug("Reason: "+str(e))
     190                                self._debug("Can't launch thread for action: %s"%action)
     191                                self._debug("Reason: %s"%e)
    191192                                pass
    192193                else:
    193                         self._debug("No function associated with action "+action)
     194                        self._debug("No function associated with action %s"%action)
    194195        #def execute_action
    195196
     
    203204        #  - The class method to execute
    204205        ####
    205         def _execute_class_method(self,action,parms=None,launchedby=None):
     206        def _execute_class_method(self,action,package_type,*args,launchedby=None,**kwargs):
    206207                exe_function=None
    207                 if not parms:
    208                         parms="*"
     208                if not package_type:
     209                        package_type="*"
    209210                if action in self.plugins_registered:
    210                         self._debug("Plugin for "+action+": "+self.plugins_registered[action][parms])
    211                         exe_function=eval(self.plugins_registered[action][parms]+"()")
     211                        self._debug("Plugin for %s: %s"%(action,self.plugins_registered[action][package_type]))
     212                        exe_function=eval(self.plugins_registered[action][package_type]+"("+','.join(args)+")")
    212213                        if self._propagate_dbg:
    213214                                exe_function.set_debug()
    214                         if self.plugins_registered[action][parms] in self.cli_mode:
     215                        if self.plugins_registered[action][package_type] in self.cli_mode:
    215216                                exe_function.cli_mode=True
    216217                        self._register_action_progress(action,exe_function,launchedby)
    217218                else:
    218                         self._debug("No plugin for action: "+action)
    219 
     219                        self._debug("No plugin for action: %s"%action)
     220                if kwargs:
     221                        self._debug("Parms: %s"%kwargs)
    220222                return (exe_function)
    221223        #def _execute_class_method
     
    257259        ####
    258260        def _join_action(self,action):
    259                 self._debug("Joining action: "+action)
     261                self._debug("Joining action: %s"%action)
    260262                try:
    261263                        self.running_threads[action].join()
    262264                except Exception as e:
    263                         self._debug("Unable to join thread for: "+action)
    264                         self._debug("Reason: "+ str(e))
     265                        self._debug("Unable to join thread for: %s"%action)
     266                        self._debug("Reason: %s"%e)
    265267                finally:               
    266268                        if action in self.running_threads.keys():
     
    277279        def _register_action_progress(self,action,function,parent_action=None):
    278280                if action in self.register_action_progress.keys():
    279                         self._debug("Appended process for action: "+action +" and function: "+str(function))
     281                        self._debug("Appended process for action: %s and function: %s"%(action,function))
    280282                        self.register_action_progress[action].append(function)
    281283                else:
    282                         self._debug("Registered process for action: "+action+" and function: "+str(function))
     284                        self._debug("Registered process for action: %s and function %s"%(action,function))
    283285                        self.register_action_progress[action]=[function]
    284286                if parent_action:
    285                         self._debug("Registered process for Parent Action: "+action+"-"+parent_action+" and function: "+str(function))
     287                        self._debug("Registered process for Parent Action: %s-%s and function: %s"%(action,parent_action,function))
    286288                        if parent_action in self.threads_progress.keys():
    287289                                self.threads_progress[parent_action].update({action:function})
     
    300302                progress={'search':0,'list':0,'install':0,'remove':0,'load':0,'list_sections':0}
    301303                action_list=[]
    302                 if action and action in self.register_action_progress:
     304                if action in self.register_action_progress.keys():
    303305                        action_list=[action]
    304306                else:
     
    342344                                                result[res]=[]
    343345                else:
    344                         self._debug("Checking result for action "+action)
     346                        self._debug("Checking result for action %s"%action)
    345347                        if self.is_action_running(action):
    346348                                self._join_action(action)
     
    366368        def get_status(self,action=None):
    367369                self.lock.acquire()
    368                 self._debug("Checking status for action "+str(action))
     370                self._debug("Checking status for action %s"%action)
    369371                result={}
    370372                if action in self.result:
     
    390392                action='load'
    391393                for package_type in self.plugins_registered[action]:
    392                         load_function=self._execute_class_method(action,package_type,None)
     394                        load_function=self._execute_class_method(action,package_type,launchedby=None)
    393395                        self.store=load_function.execute_action(action=action,store=self.store)['data']
    394396        #def _load_Store
     
    403405        def _get_App_Info(self,applist,launchedby=None):
    404406                action='get_info'
    405                 info_function=self._execute_class_method(action,None,launchedby)
     407                info_function=self._execute_class_method(action,None,launchedby=launchedby)
    406408                info_applist=info_function.execute_action(self.store,action,applist)
    407409                return(info_applist)
     
    423425                result['status']={'status':0,'msg':''}
    424426                for app_info in info_applist:
    425 #                       result['data'].append(app_info)
    426427                        package_type=self._check_package_type(app_info)
    427428                        if package_type in types_dict:
     
    430431                                types_dict[package_type]=[app_info]
    431432                for package_type in types_dict:
    432                         self._debug("Checking plugin for "+action+ " "+package_type)
     433                        self._debug("Checking plugin for %s %s"%(action,package_type))
    433434                        if package_type in self.plugins_registered[action]:
    434 #                               result['data']=[]
    435435                                #Only search full info if it's required
    436436                                if (fullsearch==False and package_type=='deb'):
    437437                                        result['data'].extend(types_dict[package_type])
    438438                                        continue
    439                                 self._debug("Retrieving info for "+str(types_dict[package_type]))
    440                                 info_function=self._execute_class_method(action,package_type,launchedby)
    441 #                               result.update(info_function.execute_action(action,types_dict[package_type]))
     439                                self._debug("Retrieving info for %s"%types_dict[package_type])
     440                                info_function=self._execute_class_method(action,package_type,launchedby=launchedby)
    442441                                result['data'].extend(info_function.execute_action(action,types_dict[package_type])['data'])
    443 #                               result['status']=info_function.execute_action(action,types_dict[package_type])['status']
    444 #                               result=info_function.execute_action(action,types_dict[package_type])
    445442                        else:
    446443                                result['data'].append(app_info)
     
    454451                status={}
    455452                if action in self.plugins_registered.keys():
    456                         self._debug("Plugin for generic search: "+self.plugins_registered[action]['*'])
     453                        self._debug("Plugin for generic search: %s"%self.plugins_registered[action]['*'])
    457454                        finder=self.plugins_registered[action][('*')]
    458455                        search_function=eval(finder+"()")
     
    461458                        data=result['data']
    462459                else:
    463                         print("No plugin for action "+action)
     460                        print("No plugin for action %s"%action)
    464461                self.result[action]['data']=data
    465462                self.result[action]['status']=status
    466                 self._debug("Sections: "+str(self.result[action]['data']))
    467                 self._debug("Status: "+str(self.result[action]['status']))
     463                self._debug("Sections: %s"%self.result[action]['data'])
     464                self._debug("Status: %s"%self.result[action]['status'])
    468465
    469466        ####
     
    474471        #  - List of dicts with all the info
    475472        ####
    476         def _search_Store(self,search_item='',action='search',fullsearch=False,launchedby=None,max_results=0):
    477                 if type(search_item[-1])==type(1):
    478                         max_results=search_item[-1]
    479                         search_item=search_item[:-1]
    480                 applist={}
     473        def _search_Store(self,*args,**kwargs):
     474                search_item=args[0]
     475                action='search'
     476                if 'action' in kwargs.keys():
     477                        action=kwargs['action']
     478                launchedby=None
     479                if 'launchedby' in kwargs.keys():
     480                        launchedby=kwargs['launchedby']
     481                max_results=0
     482                if 'max_results' in kwargs.keys():
     483                        max_results=kwargs['max_results']
     484                fullsearch=False
     485                if 'fullsearch' in kwargs.keys():
     486                        fullsearch=kwargs['fullsearch']
    481487                result={}
    482                 aux_applist=[]
    483                 if action=='list':
    484                         try:
    485                                 search_item=' '.join(search_item)
    486                         except:
    487                                 search_item=''
    488                 elif action=='list_sections':
     488                tmp_applist=[]
     489                if action=='list_sections':
    489490                        search_item=''
    490491                elif action=='info':
     
    497498                                exact_match=False
    498499                for package_type in self.plugins_registered[action]:
    499                         search_function=self._execute_class_method(action,'*',launchedby)
     500                        search_function=self._execute_class_method(action,'*',launchedby=launchedby)
    500501                        result.update(search_function.execute_action(self.store,action,search_item,exact_match,max_results))
    501                 aux_applist=result['data']
     502                tmp_applist=result['data']
    502503                status=result['status']
    503504                realAction=action
     
    506507                        subordinate_action='get_info'
    507508                        self.result[subordinate_action]={}
    508                         result=self._get_App_Info(aux_applist,launchedby)
    509                         self._debug("Add result for "+subordinate_action)
     509                        result=self._get_App_Info(tmp_applist,launchedby)
     510                        self._debug("Add result for %s"%subordinate_action)
    510511                        self.result[subordinate_action]=result
    511512                        #2.- Get rest of metadata (slower)
     
    514515                        if launchedby:
    515516                                realAction=launchedby
    516                                 self._debug("Assigned results of "+action+" to "+realAction)
     517                                self._debug("Assigned results of %s to %s"%(action,realAction))
    517518                        if (result['status']['status']==0) or (result['status']['status']==9):
    518519                                return_msg=True
     
    535536        #  - Result of the operation
    536537        ####
    537         def _install_remove_App(self,appName,action='install',launchedby=None):
    538                 self._log("Attempting to "+action +" "+appName)
     538        def _install_remove_App(self,*args,**kwargs):
     539                appName=args[0]
     540                if 'action' in kwargs.keys():
     541                        action=kwargs['action']
     542                self._log("Attempting to %s %s"%(action,appName))
    539543                result={}
    540544                return_msg=False
    541                 if (self._search_Store(appName,'search',True,action)):
     545                if (self._search_Store(appName,action='search',fullsearch=True,launchedby=action)):
    542546                        info_applist=self.result[action]['data']
    543547                        types_dict={}
    544548                        #Check if package is installed if we want to remove it or vice versa
    545549                        for app_info in info_applist:
    546 #Appstream doesn't get the right status in all cases so we rely on the mechanisms given by the different plugins.
     550                        #Appstream doesn't get the right status in all cases so we rely on the mechanisms given by the different plugins.
    547551                                if (action=='install' and app_info['state']=='installed') or (action=='remove' and app_info['state']=='available'):
    548552                                        if (action=='remove' and app_info['state']=='available'):
     
    564568
    565569                        for package_type in types_dict:
    566                                 self._debug("Checking plugin for "+action+ " "+package_type)
     570                                self._debug("Checking plugin for %s %s"%(action,package_type))
    567571                                if package_type in self.plugins_registered[action]:
    568                                         install_function=self._execute_class_method(action,package_type,action)
     572                                        install_function=self._execute_class_method(action,package_type,launchedby=action)
    569573                                        if package_type=='zmd':
    570574                                        #If it's a zmd the zomando must be present in the system
     
    572576                                                for zmd_bundle in types_dict[package_type]:
    573577                                                        zmdInfo={}
    574                                                         self._debug("Cheking presence of zmd "+ zmd_bundle['package'])
     578                                                        self._debug("Cheking presence of zmd %s"%zmd_bundle['package'])
    575579                                                        zmd='/usr/share/zero-center/zmds/'+app_info['package']+'.zmd'
    576580                                                        if not os.path.exists(zmd):
     
    579583                                                if zmd_info:
    580584                                                        self._debug("Installing needed packages")
    581                                                         install_depends_function=self._execute_class_method(action,"deb",action)
     585                                                        install_depends_function=self._execute_class_method(action,"deb",launchedby=action)
    582586                                                        result=install_depends_function.execute_action(action,zmd_info)
    583587                                                       
     
    594598                                                                self._debug("App state changed to available")
    595599                                        return_msg=True
    596                 self._log("Result "+action +": "+str(self.result[action]))
     600                self._log("Result %s: %s"%(action,self.result[action]))
    597601                return(return_msg)
    598602        #def install_App
     
    613617                else:
    614618                #Standalone installers must have an installerUrl field loaded from a bundle type=script description
    615                         if app_info['installerUrl']!='':
     619                        if app_info['bundle']!='':
     620                                return_msg=app_info['bundle']
     621                        elif app_info['installerUrl']!='':
    616622                                return_msg="sh"
    617                         elif app_info['bundle']!='':
    618                                 return_msg=app_info['bundle']
    619623                        else:
    620624                                return_msg="deb"
Note: See TracChangeset for help on using the changeset viewer.