Changeset 8223 for lliurex-store


Ignore:
Timestamp:
Nov 2, 2018, 9:15:56 AM (12 months ago)
Author:
Juanma
Message:

Implemented cache

Location:
lliurex-store/trunk/fuentes
Files:
1 added
12 edited

Legend:

Unmodified
Added
Removed
  • lliurex-store/trunk/fuentes/debian/changelog

    r8186 r8223  
     1lliurex-store (0.7) xenial; urgency=medium
     2
     3  * Implemented cache for package info
     4
     5 -- Juanma Navarro Mañez <juanma1980@gmail.com>  Fri, 02 Nov 2018 09:15:13 +0100
     6
    17lliurex-store (0.6.2) xenial; urgency=medium
    28
  • lliurex-store/trunk/fuentes/lliurex-store-cli/usr/share/lliurex-store/lliurex-store-cli.py

    r8182 r8223  
    130130        appimage=False
    131131        snap=False
     132        autostart=True
    132133        args=process_Args(sys.argv)
    133134#       if args.debug:
     
    137138        if args.snap:
    138139                snap=True
     140        if args.update:
     141                actions.append('cache')
     142                parms['cache']=None
     143                autostart=False
    139144        if args.view:
    140145                actions.append('info')
     
    152157#               actions.append('random')
    153158#               parms['random']=args.random
    154         if args.list:
    155                 actions.append('list')
    156                 parms['list']=args.list
    157 
    158         actionList={'search':False,'info':False,'pkgInfo':False,'install':False,'remove':False,'list':False,'list-sections':False,'random':False}
     159#       if args.list:
     160#               actions.append('list')
     161#               parms['list']=args.list
     162
     163        actionList={'search':False,'info':False,'pkgInfo':False,'install':False,'remove':False,'list':False,'list-sections':False,'random':False,'cache':False}
    159164        start_time=time.time()
    160         store=storeManager.StoreManager(appimage=appimage,snap=snap,dbg=dbg,cli=True)
     165        store=storeManager.StoreManager(appimage=appimage,snap=snap,dbg=dbg,autostart=autostart,cli=True)
    161166        for action in actions:
    162167                th=threading.Thread(target=store.execute_action, args = (action,parms[action]))
     
    200205        parser.add_argument('--appimage',action='store_true',help=(_(u"Load appimage catalog")))
    201206        parser.add_argument('--snap',action='store_true',help=(_(u"Load snap catalog")))
    202         parser.add_argument('--list',metavar='list',nargs='?',help=(_(u"List category")))
     207        parser.add_argument('--update',action='store_true',help=(_(u"Update cache")))
     208#       parser.add_argument('--list',metavar='list',nargs='?',help=(_(u"List category")))
    203209
    204210        args=parser.parse_args()
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/appImageManager.py

    r8185 r8223  
    4848        def set_debug(self,dbg=True):
    4949                self.dbg=dbg
    50                 self._debug ("Debug enabled")
     50                #self._debug ("Debug enabled")
    5151        #def set_debug
    5252
     
    5858        def register(self):
    5959                return(self.plugin_actions)
     60        #def register
    6061
    6162        def enable(self,state=False):
    6263                self.disable=state
     64        #def enable
    6365
    6466        def execute_action(self,action,applist=None,store=None):
     
    8082                        if action=='load':
    8183                                self._load_appimage_store(self.store)
    82                                 #wait till threads end (if any)
    83                                 self._debug("Ending threads...")
    84                                 for th in threading.enumerate():
    85                                         if th.is_alive():
    86                                                 try:
    87                                                         th.join(5)
    88                                                 except:
    89                                                         pass
     84                                #self._debug("Ending threads...")
    9085                                while not self.apps_for_store.empty():
    9186                                        app=self.apps_for_store.get()
     
    105100                self.progress=100
    106101                return(self.result)
     102        #def execute_action
    107103
    108104        def _set_status(self,status,msg=''):
     
    122118                if (self.progress>limit):
    123119                        self.progress=limit
     120        #def _callback
    124121
    125122        def _chk_installDir(self):
     
    131128                                msg_status=False
    132129                return msg_status                               
     130        #def _chk_installDir
    133131
    134132        def _install_appimage(self,app_info):
    135                 app_info=self._get_info(app_info)
    136                 self._debug("Installing %s"%app_info)
     133                app_info=self._get_info(app_info,force=True)
     134                #self._debug("Installing %s"%app_info)
    137135                if app_info['state']=='installed':
    138136                        self._set_status(4)
     
    140138                        if 'appimage' in app_info['channel_releases'].keys():
    141139                                appimage_url=app_info['channel_releases']['appimage'][0]
    142                         self._debug("Downloading "+appimage_url)
     140                        else:
     141                                #self._debug("No url in: %s"%app_info['channel_releases'])
     142                        #self._debug("Downloading "+appimage_url)
    143143                        dest_path=self.appimage_dir+'/'+app_info['package']
    144144                        if appimage_url:
     
    167167
    168168        def _remove_appimage(self,app_info):
    169                 self._debug("Removing "+app_info['package'])
     169                #self._debug("Removing "+app_info['package'])
    170170                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
    171171                        try:
     
    192192                        if int(epoch_time)-int(fcache_update)<86400:
    193193                                if os.listdir(os.path.dirname(self.cache_xmls)):
    194                                         self._debug("Loading appimage from cache")
     194                                        #self._debug("Loading appimage from cache")
    195195                                        sw_update_cache=False
    196196                if sw_update_cache:
     
    200200                        fcache.write(str(int(time.time())))
    201201                if os.path.exists(self.cache_xmls):
    202                         self._debug("Loading appimage catalog")
     202                        #self._debug("Loading appimage catalog")
    203203                        store=self._generic_file_load(self.cache_xmls,store)
    204204                return(store)
     
    213213                        if target_file.endswith('.xml'):
    214214                                store_path=Gio.File.new_for_path(target_path+'/'+target_file)
    215                                 self._debug("Adding file "+target_path+'/'+target_file)
     215                                #self._debug("Adding file "+target_path+'/'+target_file)
    216216                                try:
    217217                                        store.from_file(store_path,icon_path,None)
    218218                                except Exception as e:
    219                                         self._debug("Couldn't add file "+target_file+" to store")
    220                                         self._debug("Reason: "+str(e))
     219                                        #self._debug("Couldn't add file "+target_file+" to store")
     220                                        #self._debug("Reason: "+str(e))
     221                                        pass
    221222                return(store)
    222223        #def _generic_file_load
     
    233234                                        os.makedirs(self.cache_xmls)
    234235                                except:
    235                                         self._debug("appImage catalogue could not be fetched: Permission denied")
    236                         self._debug("Fetching repo %s"%repo_info['url'])
     236                                        #self._debug("appImage catalogue could not be fetched: Permission denied")
     237                                        pass
     238                        #self._debug("Fetching repo %s"%repo_info['url'])
    237239                        if repo_info['type']=='json':
    238240                                applist=self._process_appimage_json(self._fetch_repo(repo_info['url']),repo_name)
    239241
    240                         self._debug("Fetched repo "+repo_info['url'])
     242                        #self._debug("Fetched repo "+repo_info['url'])
    241243                        self._th_generate_xml_catalog(applist,outdir,repo_info['url_info'],repo_info['url'],repo_name)
    242244                        all_apps.extend(applist)
     
    273275                                if 'version' in app_info.keys():
    274276                                        appinfo['reywords']=app_info['keywords']
    275                                 self._debug("Fetching external appimage %s"%app_info['url'])
     277                                #self._debug("Fetching external appimage %s"%app_info['url'])
    276278                                appinfo['bundle']='appimage'
    277                                 self._debug("External:\n%s\n-------"%appinfo)
     279                                #self._debug("External:\n%s\n-------"%appinfo)
    278280                                applist.append(appinfo)
    279281                        else:
    280                                 self._debug("External appImage could not be fetched: Permission denied")
     282                                #self._debug("External appImage could not be fetched: Permission denied")
     283                                pass
    281284                self._th_generate_xml_catalog(applist,outdir,app_info['url_info'],app_info['url'],app_name)
    282                 self._debug("Fetched appimage "+app_info['url'])
     285                #self._debug("Fetched appimage "+app_info['url'])
    283286                all_apps.extend(applist)
    284                 self._debug("Removing old entries...")
     287                #self._debug("Removing old entries...")
    285288#               self._clean_bundle_catalogue(all_apps,outdir)
    286289                return(True)
     
    302305                                        external_appimages=json.load(appimages)
    303306                        except:
    304                                 self._debug("Can't load %s"%self.external_appimages)
     307                                #self._debug("Can't load %s"%self.external_appimages)
     308                                pass
    305309                return external_appimages
    306310        #def _get_external_appimages
     
    327331
    328332        def load_json_appinfo(self,appimage):
    329                 self._debug(appimage)
     333                #self._debug(appimage)
    330334                appinfo=self._init_appinfo()
    331335                appinfo['name']=appimage['name']
     
    345349                        appinfo['icon']=appimage['icon']
    346350                if 'icons' in appimage.keys():
    347                         self._debug("Loading icon %s"%appimage['icons'])
     351                        #self._debug("Loading icon %s"%appimage['icons'])
    348352                        if appimage['icons']:
    349                                 self._debug("Loading icon %s"%appimage['icons'][0])
     353                                #self._debug("Loading icon %s"%appimage['icons'][0])
    350354                                appinfo['icon']=appimage['icons'][0]
    351355                if 'screenshots' in appimage.keys():
     
    360364                                for author in appimage['authors']:
    361365                                        if 'url' in author.keys():
    362                                                 self._debug("Author: %s"%author['url'])
     366                                                #self._debug("Author: %s"%author['url'])
    363367                                                appinfo['homepage']=author['url']
    364368                else:
     
    378382                        threads.append(th)
    379383                        th.start()
     384                for thread in threads:
     385                        thread.join()
    380386        #def _th_generate_xml_catalog
    381387
     
    388394        def _add_appimage(self,appinfo):
    389395                #Search in local store for the app
    390                 sw_new=False
     396                sw_new=True
    391397                app=appstream.App()
    392398                app_orig=self.store.get_app_by_pkgname(appinfo['name'].lower())
     
    394400                        app_orig=self.store.get_app_by_id(appinfo['name'].lower()+".desktop")
    395401                if app_orig:
    396                         self._debug("Extending app %s"%appinfo['package'])
    397                         app=self._copy_app_from_appstream(app_orig,app)
    398                 else:
    399                         self._debug("Generating new %s"%appinfo['package'])
     402                        #self._debug("Extending app %s"%appinfo['package'])
     403                        if appinfo['icon']:
     404                                #self._debug("Icon: %s"%appinfo['icon'])
     405                                app=self._copy_app_from_appstream(app_orig,app,copy_icon=False)
     406                        else:
     407                                app=self._copy_app_from_appstream(app_orig,app,copy_icon=True)
     408                        sw_new=False
     409                else:
     410                        #self._debug("Generating new %s"%appinfo['package'])
     411                        pass
    400412                if appinfo['name'].endswith('.appimage'):
    401413                        app.set_id("appimagehub.%s"%appinfo['name'].lower())
     
    409421                        app.add_pkgname(appinfo['package'].lower()+".appimage")
    410422                app.set_id_kind=appstream.IdKind.DESKTOP
    411                 sw_new=True
    412423
    413424                if appinfo['license']:
     
    433444                        if not appinfo['name'].endswith('.appimage'):
    434445                                app.set_name("C",appinfo['name']+".appimage")
     446                        desc_header="This is an AppImage bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully."%appinfo['name']
    435447                        if appinfo['description']:
    436448                                for lang,desc in appinfo['description'].items():
    437                                         description="This is an AppImage bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully.\n%s"%(appinfo['name'],desc)
    438                                         summary=' '.join(list(description.split(' ')[:8]))
     449                                        desc=desc.replace('&','&amp;')
     450                                        description="<p>%s</p><p>%s</p>"%(desc_header,desc)
     451                                        summary=' '.join(list(desc.split(' ')[:10]))
    439452                                        app.set_description(lang,description)
    440453                                        app.set_comment(lang,summary)
    441454                        else:
    442                                 description="This is an AppImage bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully"%(appinfo['name'])
    443                                 summary=' '.join(list(description.split(' ')[:8]))
     455                                description="<p>%s</p>"%(desc_header)
     456                                summary=' '.join(list(desc_header.split(' ')[:8]))
    444457                                app.set_description("C",description)
    445458                                app.set_comment("C",summary)
     
    483496                        xml_data=xml_file.readlines()
    484497                        xml_file.close()
    485                         self._debug("fixing %s"%xml_path)
     498                        #self._debug("fixing %s"%xml_path)
    486499                        try:
    487                                 xml_data[0]=xml_data[0]+"<components>\n"
     500                                xml_data[0]=xml_data[0]+"<components origin=\"%s\">\n"%app.get_origin()
    488501                                xml_data[-1]=xml_data[-1]+"\n"+"</components>"
    489502                        except:
     
    492505                        xml_file.writelines(xml_data)
    493506                        xml_file.close()
    494 
    495507        #def _add_appimage
    496508
    497         def _copy_app_from_appstream(self,app_orig,app):
     509        def _copy_app_from_appstream(self,app_orig,app,copy_icon=True):
     510                desc_header="This is an AppImage bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully."%app_orig.get_pkgnames()[0]
    498511                app.set_id("appimage."+app_orig.get_id())
    499512                for category in app_orig.get_categories():
    500513                        app.add_category(category)
     514                app.add_category("appimage")
    501515                for screenshot in app_orig.get_screenshots():
    502516                        app.add_screenshot(screenshot)
    503                 for icon in app_orig.get_icons():
    504                         app.add_icon(icon)
     517                if copy_icon:
     518                        for icon in app_orig.get_icons():
     519                                app.add_icon(icon)
    505520                for localeItem in self.locale:
    506521                        if app_orig.get_name(localeItem):
    507522                                app.set_name(localeItem,app_orig.get_name(localeItem)+".appimage")
    508523                        if app_orig.get_description(localeItem):
    509                                 app.set_description(localeItem,app_orig.get_description(localeItem))
     524                                app.set_description(localeItem,"<p>%s</p><p>%s</p>"%(desc_header,app_orig.get_description(localeItem)))
    510525                        if app_orig.get_comment(localeItem):
    511526                                app.set_comment(localeItem,app_orig.get_comment(localeItem))
    512527                app.set_origin(app_orig.get_origin())
    513528                return app
     529        #def _copy_app_from_appstream
    514530
    515531        def _clean_bundle_catalogue(self,applist,outdir):
     
    532548                if not os.path.isfile(target_file):
    533549                        if not os.path.isfile(target_file):
    534                                 self._debug("Downloading %s to %s"%(url,target_file))
     550                                #self._debug("Downloading %s to %s"%(url,target_file))
    535551                                try:
    536552                                        with urllib.request.urlopen(url) as response, open(target_file, 'wb') as out_file:
     
    545561                                        st = os.stat(target_file)
    546562                                except Exception as e:
    547                                         self._debug("Unable to download %s"%url)
    548                                         self._debug("Reason: %s"%e)
     563                                        #self._debug("Unable to download %s"%url)
     564                                        #self._debug("Reason: %s"%e)
    549565                                        target_file=''
    550566                return(target_file)
     
    592608        #def _init_appinfo
    593609       
    594         def _get_info(self,app_info):
    595                 if app_info['installerUrl']:
    596                         self._debug("installer: %s"%app_info['installerUrl'])
    597                         app_info['channel_releases']={'appimage':[]}
    598                         app_info['channel_releases']['appimage']=self._get_releases(app_info)
     610        def _get_info(self,app_info,force=False):
     611                #self._debug("Searching for %s in %s"%(app_info['package'],self.appimage_dir))
    599612                app_info['state']='available'
    600613                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
    601614                        app_info['state']='installed'
    602                 #Get size
    603                 if 'appimage' in app_info['channel_releases'].keys():
    604                         if app_info['channel_releases']['appimage'][0]:
    605                                 appimage_url=app_info['channel_releases']['appimage'][0]
    606                                 dest_path=self.appimage_dir+'/'+app_info['package']
    607                                 if appimage_url:
    608                                         try:
    609                                                 with urllib.request.urlopen(appimage_url) as response:
    610                                                         app_info['size']=(response.info()['Content-Length'])
    611                                         except:
    612                                                 app_info['size']=0
    613                         else:
    614                                 app_info['size']=0
    615                         #Version (unaccurate aprox)
    616                         app_info['version']=app_info['channel_releases']['appimage'][0].split('/')[-2]
     615                if not app_info['size'] or force:
     616                        if app_info['installerUrl']:
     617                                #self._debug("installer: %s"%app_info['installerUrl'])
     618                                app_info['channel_releases']={'appimage':[]}
     619                                app_info['channel_releases']['appimage']=self._get_releases(app_info)
     620                        #Get size
     621                        app_info['size']=0
     622                        app_info['version']='unknown'
     623                        if 'appimage' in app_info['channel_releases'].keys():
     624                                if len(app_info['channel_releases']['appimage'])>0:
     625                                        if app_info['channel_releases']['appimage'][0]:
     626                                                appimage_url=app_info['channel_releases']['appimage'][0]
     627                                                dest_path=self.appimage_dir+'/'+app_info['package']
     628                                                if appimage_url:
     629                                                        try:
     630                                                                with urllib.request.urlopen(appimage_url) as response:
     631                                                                        app_info['size']=(response.info()['Content-Length'])
     632                                                        except:
     633                                                                app_info['size']=0
     634                                        #Version (unaccurate aprox)
     635                                        app_info['version']=app_info['channel_releases']['appimage'][0].split('/')[-2]
    617636
    618637                self._set_status(0)
     
    624643                releases=[]
    625644                releases_page=''
    626                 self._debug("Info url: %s"%app_info['installerUrl'])
     645                #self._debug("Info url: %s"%app_info['installerUrl'])
    627646                url_source=""
    628647                try:
     
    651670                                                        package_link=releases_page+package_link
    652671                                                        releases.append(package_link)
    653                                                         self._debug("Link: %s"%package_link)
     672                                                        #self._debug("Link: %s"%package_link)
    654673                        else:
    655674                                releases=[app_info['installerUrl']]
    656675                except Exception as e:
    657676                        print(e)
    658                 self._debug(releases)
     677                #self._debug(releases)
    659678                return releases
    660679        #def _get_releases
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py

    r8180 r8223  
    44from gi.repository import PackageKitGlib as packagekit
    55import threading
     6import time
    67from queue import Queue as pool
    78class debmanager:
     
    1213                self.progress=0
    1314                self.partial_progress=0
    14                 self.plugin_actions={'install':'deb','remove':'deb','pkginfo':'deb'}
     15                self.plugin_actions={'install':'deb','remove':'deb','pkginfo':'deb','policy':'deb'}
    1516                self.result={}
    1617                self.result['data']={}
     
    2122        def set_debug(self,dbg=True):
    2223                self.dbg=dbg
    23                 self._debug ("Debug enabled")
     24                #self._debug ("Debug enabled")
    2425        #def set_debug
    2526
     
    2829                        print ('DEBUG Deb: %s'%msg)
    2930        #def debug
    30 
    31         def _log(self,msg=None):
    32                 if msg:
    33                         syslog.openlog('lliurex-store')
    34                         syslog.syslog(msg)
    3531
    3632        def register(self):
     
    4137        #filter=2 -> only installed app installed
    4238        def execute_action(self,action,applist,filters=1):
    43                 self._debug("Executing action %s"%action)
     39                #self._debug("Executing action %s"%action)
    4440                self.progress=0
    4541                self.installer=packagekit.Client()
     
    5753                                if app:
    5854                                        if action=='install':
    59                                                 self._log("Installing "+app_info['package'])
    6055                                                self._install_App(app)
    6156                                                self.result['data'].append({'package':app_info['package']})
    6257                                        if action=='remove':
    63                                                 self._log("Removing "+app_info['package'])
    6458                                                self._remove_App(app)
    6559                                                self.result['data'].append({'package':app_info['package']})
    6660                                        if action=='pkginfo':
    67                                                 self.result['data'].append(self._get_App_Extended_Info(app_info,app))
     61                                                res=self._get_info(app_info,app)
     62                                                self.result['data'].append(res)
    6863                                        if action=='policy':
    6964                                                self._set_status(0)
     
    7671        def _set_status(self,status,msg=''):
    7772                self.result['status']={'status':status,'msg':msg}
     73        #def _set_status
    7874
    7975        def _fake_callback(self,*args):
     
    8884        def _install_App(self,app):
    8985                self.return_msg=False
    90                 self._debug("Installing %s"%app.get_id())
     86                #self._debug("Installing %s"%app.get_id())
    9187                err=0
    9288                try:
     
    9591                except Exception as e:
    9692                        print(str(e))
    97                         self._debug("Install error: %s"%e.code)
     93                        #self._debug("Install error: %s"%e.code)
    9894                        err=e.code
    9995                finally:
     
    108104                        self._set_status(0)
    109105                except Exception as e:
    110                         self._debug("Remove error: %s"%e.code)
    111                         self._debug("Remove error: %s"%e)
     106                        #self._debug("Remove error: %s"%e.code)
     107                        #self._debug("Remove error: %s"%e)
    112108                        self._set_status(e.code)
    113109                finally:
     
    116112
    117113        def _th_get_details(self,pkTask,app_info_pool,app):
    118                 self._debug("Getting details for %s"%app.get_id())
     114                #self._debug("Getting details for %s"%app.get_id())
    119115                results=pkTask.get_details([app.get_id(),],None,self._fake_callback,None)
    120116                for app_detail in results.get_details_array():
     
    124120
    125121        def _th_get_depends(self,pkTask,app_info_pool,app):
    126                 self._debug("Getting dependencies for %s"%app.get_id())
     122                #self._debug("Getting dependencies for %s"%app.get_id())
    127123                results=pkTask.get_depends(1,[app.get_id(),],False,None,self._fake_callback,None)
    128124                dependsList=[]
     
    132128        #def _th_get_depends
    133129
    134         def _get_App_Extended_Info(self,app_info,app):
     130        def _get_info(self,app_info,app):
    135131                app_info['version']=app.get_version()
    136132                app_info['arch']=app.get_id().split(';')[2]
     
    138134                results=[]
    139135                self._set_status(0)
    140                 app_info_pool=pool()
    141                 threads=[]
    142                 th=threading.Thread(target=self._th_get_details, args = (pkTask,app_info_pool,app))
    143                 threads.append(th)
    144                 th.start()
    145                 #Get depends disabled per time-costing
    146                 #th=threading.Thread(target=self._th_get_depends, args = (pkTask,app_info_pool,app))
    147                 #threads.append(th)
    148                 #th.start()
     136                #Only get size and depends if we don't have the data
     137                if not app_info['size']:
     138                        app_info_pool=pool()
     139                        threads=[]
     140                        th=threading.Thread(target=self._th_get_details, args = (pkTask,app_info_pool,app))
     141                        threads.append(th)
     142                        th.start()
     143                        #Get depends disabled per time-costing
     144                        #th=threading.Thread(target=self._th_get_depends, args = (pkTask,app_info_pool,app))
     145                        #threads.append(th)
     146                        #th.start()
     147                        for thread in threads:
     148                                try:
     149                                        thread.join()
     150                                except:
     151                                        pass
     152                        while app_info_pool.qsize():
     153                                data=app_info_pool.get()
     154                                app_info.update(data)
     155                #Get status
    149156                try:
    150157                        info=app.get_info()
    151158                        state=info.to_string(info)
    152                         if state!=app_info['state'] and app_info['state']=='installed':
     159                        if state!=app_info['state'] and state!='available' and app_info['state']=='installed':
    153160                                app_info['updatable']=1
    154161                        else:
    155162                                app_info['state']=state
    156                         self._debug("State: "+app_info['state'])
    157                 except Exception as e:
    158                         self._debug("State: not available (%s)"%e)
    159 
    160                 for thread in threads:
    161                         try:
    162                                 thread.join()
    163                         except:
     163                        #self._debug("State: %s"%state)
     164                except Exception as e:
     165                        #self._debug("State: not available (%s)"%e)
     166                        pass
     167                #self._debug("INFO: %s"%app_info)
     168                return(app_info)
     169        #def _get_info
     170
     171        def _resolve_App(self,app_name,filters=1):
     172                #self._debug("Resolving %s"%app_name)
     173                def _pk_resolve(filters,app_name):
     174                        app=None
     175                        #self._debug("Filter for resolver: %s"%filters)
     176                        result=self.installer.resolve(filters,[app_name,],None,self._fake_callback, None)
     177                        resolvelist=result.get_package_array()
     178                        #resolver bug: filters not work so if we want to remove an app first we must get the installed version...
     179                        app_resolved=None
     180                        if filters==1:
     181                                app_resolved=resolvelist[0]
     182                        elif filters==2:
     183                                for app in resolvelist:
     184                                        if (str(app.get_info()).find('PK_INFO_ENUM_INSTALLED')!=-1):
     185                                                app_resolved=app
     186                                                break
     187                        if app_resolved:
     188                                #self._debug("Application %s resolved succesfully"%app_resolved.get_name())
     189                                app=app_resolved
     190                        else:
     191                                #self._debug("Application %s NOT resolved"%app_resolved.get_name())
    164192                                pass
    165 
    166                 while app_info_pool.qsize():
    167                         data=app_info_pool.get()
    168                         app_info.update(data)
    169 
    170                 return(app_info)
    171         #def _get_App_Extended_Info
    172 
    173         def _resolve_App(self,app_name,filters=1):
    174                 self._debug("Resolving %s"%app_name)
     193                        return app
     194
    175195                app=None
    176196                resolvelist=[]
    177197                self.return_msg=False
    178198                try:
    179                         self._debug("Filter for resolver: %s"%filters)
    180                         result=self.installer.resolve(filters,[app_name,],None,self._fake_callback, None)
    181                         resolvelist=result.get_package_array()
    182                         app_resolved=resolvelist[0]
    183                         #resolver bug: filters not work so if we want to remove an app first we must get the installed version...
    184                         if filters==2:
    185                                 for app in resolvelist:
    186                                         if (str(app.get_info()).find('PK_INFO_ENUM_INSTALLED')!=-1):
    187                                                 app_resolved=app
    188                         if app_resolved:
    189                                 self._debug("Application %s resolved succesfully"%app_resolved.get_name())
    190                                 app=app_resolved
    191                 except Exception as e:
    192                         self._debug("Couldn't resolve %s"%app_name)
    193                         self._debug("Reason: %s"%e)
     199                        app=_pk_resolve(filters,app_name)
     200                except Exception as e:
     201                        #self._debug("Couldn't resolve %s"%app_name)
     202                        #self._debug("Reason: %s"%e)
     203                        #self._debug("2nd attempt")
     204                        time.sleep(0.5)
     205                        try:
     206                                app=_pk_resolve(filters,app_name)
     207                        except Exception as e:
     208                                #self._debug("Couldn't resolve %s"%app_name)
     209                                #self._debug("Reason: %s"%e)
     210                                pass
    194211                finally:
    195212                        self.partial_progress=100
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/example.py

    r7432 r8223  
    2121                #This example plugin is disabled by default
    2222                self.disabled=True
     23                #A plugin must declare autostart actions thar must be invoked when storemanager registers the plugin
     24                #The dict's key is the action's name and the value is the parameter (or None) needed for launch the action
     25                self.autostart_actions={'example':'store=self.store'} #The parameter list refers to 'stringfieds' storeManager members !!
     26                #This dict registers actions to be launched after storemanager registered actions.
     27                #In this example the action 'install' of the plugin is launched after storemanager does any 'install' action. As in autostart_actions the parameter referes to storemanager members
     28                self.postaction_actions={'install':'app','remove':'app'}
     29                #If an action requires some parameter to be launched you could declare here.
     30                self.requires={'cache':'store=self.store'}
    2331        #def __init__
    2432       
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/infoManager.py

    r7433 r8223  
    1515        def set_debug(self,dbg=True):
    1616                self.dbg=dbg
    17                 self._debug ("Debug enabled")
     17                #self._debug ("Debug enabled")
    1818        #def set__debug
    1919
     
    2727        #def register
    2828
    29         def execute_action(self,appstream,action,applist,match=False):
     29        def execute_action(self,action,applist,match=False):
    3030                self.progress=0
    31                 self.appstream=appstream
    3231                count=len(applist)
    3332                if (action=='get_info' or action=='info') and count>0:
     
    4039        def _set_status(self,status,msg=''):
    4140                self.result['status']={'status':status,'msg':msg}
     41        #def _set_status
    4242
    4343        def _callback_progress(self):
     
    5959                for app in applist:
    6060                        appInfo=self._init_appInfo()
    61 #                       self._debug("Gathering package info for "+app.get_id())
     61                        #self._debug("Gathering package info for "+app.get_id())
    6262#Earlier versions stored the appstream_id as the memory dir of the metadata
    6363#Changes in python3.6 and pickle module forces us to disable this feature...
     
    9090                                if app.get_comment(localeItem):
    9191                                        appInfo['summary']=app.get_comment(localeItem)
     92                                        appInfo['summary']=appInfo['summary'].replace('&amp;','&')
     93                                        appInfo['summary']=appInfo['summary'].replace('<p>','')
    9294                                        break
    9395                        for localeItem in self.locale:
     
    137139                                                                screenshots_list.append("/home/lliurex/.cache/lliurex-store/images/"+img.get_basename())
    138140
    139 
    140141                                        appInfo['thumbnails']=thumbnails_list
    141142                                appInfo['screenshot']=default_screenshot
    142143                                appInfo["screenshots"]=screenshots_list
    143144                        #The values are the values of appstream.UrlKind. 1=HOMEPAGE, 0=UNKNOWN
    144 #                       self._debug(app.get_url_item(0))
     145#                       #self._debug(app.get_url_item(0))
    145146                        if app.get_url_item(1):
    146147                                appInfo['homepage']=app.get_url_item(1).strip()
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/loadStore.py

    r7432 r8223  
    3030        def set_debug(self,dbg=True):
    3131                self.dbg=dbg
    32                 self._debug ("Debug enabled")
     32                #self._debug ("Debug enabled")
    3333        #def set_debug
    3434
     
    6666                for flag in flags:
    6767                        try:
    68                                 self._debug("Loading "+str(flag))
     68                                #self._debug("Loading "+str(flag))
    6969                                store.load(flag)
    7070                        except:
    7171                                print ("Failed to load"+str(flag))
    7272                                pass
    73                 #Zomandos are now available from appstream
    74 #               store=self.load_zmds_catalog(store)
    7573                store=self._sanitize_store(store)
    7674                self.store=store
     
    9088                        if target_file.endswith('appdata.xml'):
    9189                                store_file=Gio.File.new_for_path(target_dir+'/'+target_file)
    92                                 self._debug("Adding file %s/%s"%(target_dir,target_file))
     90                                #self._debug("Adding file %s/%s"%(target_dir,target_file))
    9391                                try:
    9492                                        store.from_file(store_file,icon_dir,None)
    9593                                except Exception as e:
    96                                         self._debug("Couldn't add file %s to store"%target_file)
    97                                         self._debug("Reason: %s"%e)
     94                                        #self._debug("Couldn't add file %s to store"%target_file)
     95                                        #self._debug("Reason: %s"%e)
     96                                        pass
    9897                return(store)
    9998       
     
    110109                                                a.remove_veto(veto)
    111110                                        store.add_app(a)
    112                                         self._debug("Adding app from desktop %s"%desktop_file)
     111                                        #self._debug("Adding app from desktop %s"%desktop_file)
    113112                                except:
    114113                                        pass
     
    124123                        #Zomandos get max priority
    125124                        if app.has_category('Zomando'):
    126                                 self._debug("Prioritize zmd %s"%app.get_id())
     125                                #self._debug("Prioritize zmd %s"%app.get_id())
    127126                                app.set_priority(400)
    128127                                lliurex_apps.update({app.get_id_filename():app})
     
    131130                        #Prioritize Lliurex apps
    132131                        elif app.has_category('Lliurex'):
    133                                 self._debug("Prioritize app %s"%app.get_id())
     132                                #self._debug("Prioritize app %s"%app.get_id())
    134133                                app.set_priority(200)
    135134                                lliurex_apps.update({app.get_id_filename():app})
    136135                        elif str(app.get_origin()).find('lliurex')>=0:
    137                                 self._debug("Prioritize app %s"%app.get_id())
     136                                #self._debug("Prioritize app %s"%app.get_id())
    138137                                app.set_priority(100)
    139138                                lliurex_apps.update({app.get_id_filename():app})
     
    141140                                app.set_priority(0)
    142141                                if app.get_id_filename() in lliurex_apps.keys():
    143                                         self._debug("Mergin app %s as is in LliureX"%app.get_id())
     142                                        #self._debug("Mergin app %s as is in LliureX"%app.get_id())
    144143                                        lliurex_apps[app.get_id_filename()].subsume_full(app,appstream.AppSubsumeFlags.BOTH_WAYS)
    145144#                                       store.add_app(lliurex_apps[app.get_id_filename()])
     
    149148                        #Remove add-on apps (as are included in the main packages)
    150149                        if app.get_kind()==appstream.AppKind.ADDON:
    151                                 self._debug("Removed addon %s"%app.get_pkgnames())
     150                                #self._debug("Removed addon %s"%app.get_pkgnames())
    152151                                store.remove_app(app)
    153152                        #Remove duplicated apps
     
    156155                        if pkg in tmp_store_apps.keys():
    157156                                fn=app.get_id_no_prefix()
    158                                 self._debug("Comparing %s with %s"%(fn,tmp_store_apps[pkg]['fn']))
     157                                #self._debug("Comparing %s with %s"%(fn,tmp_store_apps[pkg]['fn']))
    159158                                if fn != tmp_store_apps[pkg]['fn']:
    160159                                        if fn != pkg and ".desktop" not in fn:
    161                                                 self._debug("Removed duplicated %s"%app.get_id())
     160                                                #self._debug("Removed duplicated %s"%app.get_id())
    162161                                                store.remove_app(app)
    163162                                        else:
    164                                                 self._debug("Removed duplicated %s"%tmp_store_apps[pkg]['app'].get_id())
     163                                                #self._debug("Removed duplicated %s"%tmp_store_apps[pkg]['app'].get_id())
    165164                                                store.remove_app(tmp_store_apps[pkg]['app'])
    166165                                                tmp_store_apps.update({pkg:{'fn':app.get_id_no_prefix(),'app':app}})
    167166                        elif pkg:
    168 #                               self._debug("Adding "+app.get_id_filename()+" to uniq dict")
     167#                               #self._debug("Adding "+app.get_id_filename()+" to uniq dict")
    169168                                tmp_store_apps.update({pkg:{'fn':app.get_id_filename(),'app':app}})
    170169                #Delete zomando-related debs
     
    177176        def _purge_zomandos(self,zmd_apps,store):
    178177                for zmd_id in zmd_apps:
    179                         self._debug("Searching debs related to %s"%zmd_id)
     178                        #self._debug("Searching debs related to %s"%zmd_id)
    180179                        purge_list=store.get_apps_by_id(zmd_id)
    181180                        purge_list.extend(store.get_apps_by_id(zmd_id+".desktop"))
     
    183182                                if purge_app:
    184183                                        if not purge_app.has_category('Zomando'):
    185                                                 self._debug("Removed related zomando app %s"%purge_app.get_id())
     184                                                #self._debug("Removed related zomando app %s"%purge_app.get_id())
    186185                                                store.remove_app(purge_app)
    187186                return(store)
     
    193192                        flavour=flavour.decode("utf-8")
    194193                        if flavour=='None':
    195                                 self._debug("Unknown flavour. Switching to desktop")
     194                                #self._debug("Unknown flavour. Switching to desktop")
    196195                                flavour='desktop'
    197196                except (subprocess.CalledProcessError,FileNotFoundError) as e:
    198                                 self._debug("Running on a non Lliurex host")
     197                                #self._debug("Running on a non Lliurex host")
    199198                                flavour='desktop'
    200199                try:
     
    209208                                blacklist_re=[]
    210209                                for blacklist_app in blacklist_apps:
    211                                         self._debug("Blacklisted app: "+blacklist_app)
     210                                        #self._debug("Blacklisted app: "+blacklist_app)
    212211                                        re_result=re.search('([^a-zA-Z0-9_-])',blacklist_app)
    213212                                        if re_result:
     
    218217                                                app=store.get_app_by_pkgname(blacklist_app)
    219218                                                if app:
    220                                                         self._debug("Removed "+str(app))
     219                                                        #self._debug("Removed "+str(app))
    221220                                                        store.remove_app(app)
    222221                                                else:
    223                                                         self._debug("App %s from blacklist not found in store. Assigned to RE blacklist"%blacklist_app)
     222                                                        #self._debug("App %s from blacklist not found in store. Assigned to RE blacklist"%blacklist_app)
    224223                                                        blacklist_re.append("("+blacklist_app+")")
    225224                                if blacklist_re:
    226                                         self._debug("Attempting to remove apps by RE match")
     225                                        #self._debug("Attempting to remove apps by RE match")
    227226                                        for app in store.get_apps():
    228227                                                for blacklist_app in blacklist_re:
     
    230229                                                        if re_result:
    231230                                                                store.remove_app(app)
    232                                                                 self._debug("Removed %s as matches with %s"%(app.get_id(),blacklist_app))
     231                                                                #self._debug("Removed %s as matches with %s"%(app.get_id(),blacklist_app))
    233232                        else:
    234                                 self._debug('No blacklist to check')
     233                                #self._debug('No blacklist to check')
     234                                pass
    235235                except Exception as e:
    236                         self._debug("Error processing blacklist: %s"%e)
     236                        #self._debug("Error processing blacklist: %s"%e)
     237                        pass
    237238                finally:
    238239                        return(store)
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/searchManager.py

    r8182 r8223  
    2020        def __call__(self):
    2121                return (self.applist)
     22        #def __call__
    2223
    2324        def set_debug(self,dbg=True):
    2425                self.dbg=dbg
    25                 self._debug ("Debug enabled")
     26                #self._debug ("Debug enabled")
    2627        #def set__debug
    2728
     
    3334        def register(self):
    3435                return(self.plugin_actions)
     36        #def register
    3537
    3638        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)
     39                #self._debug("Executing action %s"%action)
     40                #self._debug("Tokens: %s"%tokens)
    3941                self.progress=0
    4042                if type(tokens)==type([]):
     
    4648                if len(tokens.split(' '))>1:
    4749                        if action=='search':
    48                                 self._debug("Tokenizing search items")
     50                                #self._debug("Tokenizing search items")
    4951                                tokens=appstream.utils_search_tokenize(tokens)
    5052                        else:
     
    6769                                self._search_app(tokens,exact_match_for_search)
    6870                else:
    69                         self._debug("Search needs a store")
     71                        #self._debug("Search needs a store")
     72                        pass
    7073                self.progress=100
    7174                return(self.result)
     75        #def execute_action
    7276
    7377        def _set_status(self,status,msg=''):
    7478                self.result['status']={'status':status,'msg':msg}
     79        #def _set_status
    7580
    7681        def set_precision(self,precision):
    7782                self.precision=precision
     83        #def set_precision
    7884
    7985        def _search_app(self,tokens,exact_match):
    80                 self._debug("Searching app "+str(tokens)+ " with exact_match="+str(exact_match))
     86                #self._debug("Searching app "+str(tokens)+ " with exact_match="+str(exact_match))
    8187                applist=[]
    8288                app=None
    83 #               if len(tokens)==1:
    8489                if exact_match:
    8590                        app=self._app_exists(tokens[0])
     
    8994                        else:
    9095                                applist.append(app)
    91 #                       self._debug("App direct match found: "+app.get_id())
     96#                       #self._debug("App direct match found: "+app.get_id())
    9297                if not exact_match:
    9398                        applist.extend(self._get_apps_by_match(tokens,applist))
    94 #               if len(applist):
    95 #                       self._set_status(0)
    96 #               else:
    9799                        applist.extend(self._get_app_by_pkgname(tokens,applist))
    98100                applist=set(applist)
     
    103105                self.result['data']=applist
    104106                return(applist)
     107        #def _search_app
    105108
    106109        def _list_sections(self):
     
    121124                        self._set_status(1)
    122125                return(applist)
     126        #def _list_sections
    123127
    124128        def _list_category(self,tokens=[],max_results=0):
    125129                applist=[]
    126                 self._debug("tokens: "+str(tokens))
    127                 self._debug("Max results: %s"%max_results)
     130                #self._debug("tokens: "+str(tokens))
     131                #self._debug("Max results: %s"%max_results)
    128132                if len(tokens)>=1:
    129                         self._debug("Searching category "+str(tokens))
     133                        #self._debug("Searching category "+str(tokens))
    130134                        categories_set=set(tokens)
    131135                        apps_in_store=self.store.get_apps()
     
    142146                                        app_categories_set=set(app_categories)
    143147                                        if categories_set.issubset(app_categories_set):
    144                                                 self._debug("Found "+app.get_id())
     148                                                #self._debug("Found "+app.get_id())
    145149                                                applist.append(app)
    146150                                                if max_results and len(applist)==max_results:
    147151                                                        break
    148152                else:
    149                         self._debug("Loading all apps in store")
     153                        #self._debug("Loading all apps in store")
    150154                        applist=self.store.get_apps()
    151155                        categories_set=set(['snap','appimage'])
     
    163167                                                print("Removing %s"%app.get_pkgname())
    164168                        applist=applist_2
    165 #                       for app in applist:
    166 #                               self._debug("Added "+app.get_id())
    167169                        if max_results:
    168170                                applist=applist[0:max_results]
     
    175177                        self._set_status(1)
    176178                return(applist)
     179        #def _list_category
    177180
    178181        def _app_exists(self,app_name):
    179                 self._debug("Trying direct match for "+app_name)
     182                #self._debug("Trying direct match for "+app_name)
    180183                #id_matches defines how to search for an app
    181184                # %s -> app_name; zero-lliurex-%s -> app_name with zero-lliurex- prefix and so on...
     
    187190                        if app:
    188191                                break
    189 
    190 
    191                 #1.- Try exact match
    192 #               app=self.store.get_apps_by_id(app_name)
    193 #               if not app:
    194 #               #2.- Try exact match with zero-lliurex- for the zomandos
    195 #                       app=self.store.get_app_by_id("zero-lliurex-"+app_name)
    196 #               if not app:
    197 #               #3.- Try exact match with .desktop
    198 #                       app=self.store.get_apps_by_id(app_name+".desktop")
    199192                if not app:
    200                 #4.- Try exact match by pkgname
     193                #2.- Try exact match by pkgname
    201194                        app=self.store.get_app_by_pkgname(app_name)
    202 #               if not app:
    203 #                       app=self.store.get_app_by_id_ignore_prefix(app_name)
    204                 self._debug("App found %s"%app)
     195                #self._debug("App found %s"%app)
    205196                return(app)
     197        #def _app_exists
    206198
    207199        def _get_apps_by_match(self,tokens,applist=[]):
    208200                #Add items with match >= self.precision
    209                 self._debug("Searching app by fuzzy match")
     201                #self._debug("Searching app by fuzzy match")
    210202                if not applist:
    211203                        position=1
     
    224216                                                score=app.search_matches(token)
    225217                                                if score>=self.precision:
    226 #                                                       if "appimage" in app.get_id().lower():
    227 #                                                               score=1
    228218                                                        if score in tmp_app_dict:
    229219                                                                tmp_app_dict[score].append(app)
     
    234224                                for app in tmp_app_dict[match]:
    235225                                        if app not in applist:
    236                                                 self._debug("Adding app "+app.get_id() + " with score: "+str(match))
     226                                                #self._debug("Adding app "+app.get_id() + " with score: "+str(match))
    237227                                                applist.insert(0,app)
    238228                return(applist)
     229        #def _get_apps_by_match
    239230
    240231        def _get_app_by_pkgname(self,tokens,applist=[]):
     
    256247
    257248                return(applist)
     249        #def _get_app_by_pkgname
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/shManager.py

    r7080 r8223  
    2323        def set_debug(self,dbg=True):
    2424                self.dbg=dbg
    25                 self._debug ("Debug enabled")
     25                #self._debug ("Debug enabled")
    2626        #def set_debug
    2727
     
    4141                if (action):
    4242                        for app_info in applist:
    43                                 self._debug("Executing action "+action+" for "+str(app_info))
     43                                #self._debug("Executing action "+action+" for "+str(app_info))
    4444                                if action=='install':
    4545                                        self.result['data'].append(self._install_App(app_info))
     
    5252        def _set_status(self,status,msg=''):
    5353                self.result['status']={'status':status,'msg':msg}
     54        #def _set_status
    5455
    5556        def _callback(self,partial_size=0,total_size=0):
     
    7071                return_msg=False
    7172                app_url=app_info['installerUrl']
    72                 self._debug("Checking availabilty for "+app_url)
     73                #self._debug("Checking availabilty for "+app_url)
    7374                tmp_dir=tempfile.mkdtemp(None,None,'/tmp')
    7475                file_name=app_url.split('/')[-1]
     
    8081                        try:
    8182                                sudo_cmd=['gksudo',dest_path]
    82                                 self._debug("executing "+str(sudo_cmd))
     83                                #self._debug("executing "+str(sudo_cmd))
    8384                                launched_cmd=subprocess.Popen(sudo_cmd,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
    8485#                               launched_cmd=subprocess.check_output(sudo_cmd)
     
    9697                                cmd_status=launched_cmd.stdout.read()
    9798                                cmd_err=launched_cmd.stderr.read()
    98                                 self._debug("Error: "+str(cmd_err))
    99                                 self._debug("Result: "+str(cmd_status))
     99                                #self._debug("Error: "+str(cmd_err))
     100                                #self._debug("Result: "+str(cmd_status))
    100101                        except subprocess.CalledProcessError as callError:
    101102#                               err=callError.returncode
     
    103104                                err=303
    104105                        except Exception as e:
    105                                 self._debug(str(e))
     106                                #self._debug(str(e))
    106107                                err=12
    107108                else:
     
    116117                        tmp_dir=tempfile.mkdtemp(None,None,'/tmp')
    117118                        dest_path=tmp_dir+'/'+app_url.split('/')[-1]
    118                 self._debug("Downloading "+app_url+" to "+dest_path)   
     119                #self._debug("Downloading "+app_url+" to "+dest_path)   
    119120                try:
    120121#                       urllib.request.urlretrieve(app_url,dest_path)
     
    131132                        return_msg=True
    132133                except Exception as e:
    133                         self._debug(str(e))
     134                        #self._debug(str(e))
    134135                        return_msg=False
    135136                return return_msg
     
    138139        def _get_Sh_Info(self,app_info):
    139140                app_url=app_info['installerUrl']
    140                 self._debug("Connecting to "+app_url)
     141                #self._debug("Connecting to "+app_url)
    141142                app_url.strip()
    142143                try:
     
    148149                self._set_status(err)
    149150                return(app_info)
     151        #def _get_Sh_Info
    150152
    151153        #def _get_info
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/snapManager.py

    r8185 r8223  
    3939                        except:
    4040                                self.icon_cache_enabled=False
    41                                 self._debug("Icon cache disabled")
     41                                #self._debug("Icon cache disabled")
    4242                if not os.path.isdir(self.images_folder):
    4343                        try:
     
    4545                        except:
    4646                                self.image_cache_enabled=False
    47                                 self._debug("Image cache disabled")
     47                                #self._debug("Image cache disabled")
    4848        #def __init__
    4949
    5050        def set_debug(self,dbg=True):
    5151                self.dbg=dbg
    52                 self._debug ("Debug enabled")
     52                #self._debug ("Debug enabled")
    5353        #def set_debug
    5454
     
    6060        def register(self):
    6161                return(self.plugin_actions)
     62        #def register
    6263
    6364        def enable(self,state=False):
    6465                self.disabled=state
     66        #def enable
    6567
    6668        def execute_action(self,action,applist=None,store=None,results=0):
     
    7375                self.result['data']=''
    7476               
     77                self.snap_client=Snapd.Client()
     78                try:
     79                        self.snap_client.connect_sync(None)
     80                except Exception as e:
     81                        self.disabled=True
     82                        #self._debug("Disabling snap %s"%e)
    7583
    7684                if self.disabled==True:
     
    7987                else:
    8088                        self._check_dirs()
    81                         self.snap_client=Snapd.Client()
    82                         self.snap_client.connect_sync(None)
    8389                        dataList=[]
    8490                        if action=='load':
     
    99105                self.progress=100
    100106                return(self.result)
     107        #def execute_action
    101108
    102109        def _set_status(self,status,msg=''):
     
    117124                if not os.path.isdir(self.cache_xmls):
    118125                        os.makedirs(self.cache_xmls)
     126        #def _check_dirs
    119127
    120128        def _load_snap_store(self,store):
     
    129137                        if int(epoch_time)-int(fcache_update)<86400:
    130138                                if os.listdir(os.path.dirname(self.cache_xmls)):
    131                                         self._debug("Loading snap from cache")
     139                                        #self._debug("Loading snap from cache")
    132140                                        store=self._load_from_cache(store)
    133141                                        return store
     
    153161                        store.add_app(store_pool.get())
    154162                return(store)
     163        #def _load_snap_store
    155164
    156165        def _th_load_store(self,store,pkg,semaphore):
     
    158167                app=self.store.get_app_by_pkgname(pkg.get_name())
    159168                if not app:
    160                         self._debug("Searching for %s"%pkg.get_name())
     169                        #self._debug("Searching for %s"%pkg.get_name())
    161170                        app=self.store.get_app_by_id(pkg.get_name().lower()+".desktop")
    162171                        if app:
     
    170179                                store.put(self._generate_appstream_app_from_snap(pkg))
    171180                semaphore.release()
     181        #def _th_load_store
    172182
    173183        def _load_from_cache(self,store):
     
    175185                        if target_file.endswith('.xml'):
    176186                                store_file=Gio.File.new_for_path(self.cache_xmls+'/'+target_file)
    177                                 self._debug("Adding file %s/%s"%(self.cache_xmls,target_file))
     187                                #self._debug("Adding file %s/%s"%(self.cache_xmls,target_file))
    178188                                try:
    179189                                        store.from_file(store_file,'',None)
    180190                                except Exception as e:
    181                                         self._debug("Couldn't add file %s to store"%target_file)
    182                                         self._debug("Reason: %s"%e)
     191                                        #self._debug("Couldn't add file %s to store"%target_file)
     192                                        #self._debug("Reason: %s"%e)
     193                                        pass
    183194                return store   
     195        #def _load_from_cache
    184196
    185197        def _generate_appstream_app_from_snap(self,pkg):
     
    243255                        xml_data=xml_file.readlines()
    244256                        xml_file.close()
    245                         self._debug("fixing %s"%xml_path)
     257                        #self._debug("fixing %s"%xml_path)
    246258                        try:
    247259                                xml_data[0]=xml_data[0]+"<components>\n"
     
    253265                        xml_file.close()
    254266                return(app)
     267        #def _generate_appstream_app_from_snap
    255268
    256269        def _search_cb(self,obj,request,*args):
    257270                global wrap
    258271                wrap=request
     272        #def _search_cb
    259273
    260274        def _load_sections(self):
     
    266280                                stable_pkgs.append(pkg)
    267281                return(stable_pkgs)
     282        #def _load_sections
    268283
    269284        def _search_snap_async(self,tokens,force_stable=True):
    270                 self._debug("Async Searching %s"%tokens)
     285                #self._debug("Async Searching %s"%tokens)
    271286                pkgs=None
    272287                global wrap
     
    288303                                        stable_pkgs.append(pkg)
    289304                                else:
    290                                         self._debug(pkg.get_channel())
     305                                        #self._debug(pkg.get_channel())
     306                                        pass
    291307                        else:
    292308                                stable_pkgs.append(pkg)
    293309                return(stable_pkgs)
     310        #def _search_snap_async
    294311
    295312        def _search_snap(self,tokens,force_stable=True):
    296                 self._debug("Searching %s"%tokens)
     313                #self._debug("Searching %s"%tokens)
    297314                pkg=None
    298315                pkgs=None
     
    308325                                        stable_pkgs.append(pkg)
    309326                                else:
    310                                         self._debug(pkg.get_channel())
     327                                        #self._debug(pkg.get_channel())
     328                                        pass
    311329                        else:
    312330                                stable_pkgs.append(pkg)
    313                 self._debug("Done")
     331                #self._debug("Done")
    314332                return(stable_pkgs)
    315333        #def _search_snap
     
    319337                if not os.path.isfile(target_file):
    320338                        if not os.path.isfile(target_file):
    321                                 self._debug("Downloading %s to %s"%(url,target_file))
     339                                #self._debug("Downloading %s to %s"%(url,target_file))
    322340                                try:
    323341                                        with urllib.request.urlopen(url) as response, open(target_file, 'wb') as out_file:
     
    332350                                        st = os.stat(target_file)
    333351                                except Exception as e:
    334                                         self._debug("Unable to download %s"%url)
    335                                         self._debug("Reason: %s"%e)
     352                                        #self._debug("Unable to download %s"%url)
     353                                        #self._debug("Reason: %s"%e)
    336354                                        target_file=''
    337355                return(target_file)
     
    341359        def _get_info(self,app_info):
    342360                #switch to launch async method when running under a gui
    343                 #For an unknown reason request will block when sync mode under a gui and async blocks when on cli (really funny)
    344                 self._debug("Getting info for %s"%app_info)
     361                #Request will block when in sync mode under a gui and async mode blocks when on cli (really funny)
     362                #self._debug("Getting info for %s"%app_info)
    345363                pkg=None
    346364                try:
     
    350368                except:
    351369                        app_info['state']='available'
     370                if not app_info['size']:
    352371                        if self.cli_mode:
    353372                                pkgs=self._search_snap(app_info['package'].replace('.snap',''),force_stable=False)
    354373                        else:
    355374                                pkgs=self._search_snap_async(app_info['package'].replace('.snap',''),force_stable=False)
    356                         self._debug("Getting extended info for %s %s"%(app_info['package'],pkgs))
    357                 if type(pkgs)==type([]):
    358                         for pkg in pkgs:
    359                                 self._debug("Getting extended info for %s"%app_info['name'])
    360                                 if pkg.get_download_size():
    361                                         app_info['size']=str(pkg.get_download_size())
    362                                 elif pkg.get_installed_size():
    363                                         app_info['size']=str(pkg.get_installed_size())
    364                                 else:
    365                                         app_info['size']="-1"
    366                                 break
    367                 else:
    368                         app_info['size']='0'
    369                 self._debug("Info for %s"%app_info)
     375                        #self._debug("Getting extended info for %s %s"%(app_info['package'],pkgs))
     376                        if type(pkgs)==type([]):
     377                                for pkg in pkgs:
     378                                        #self._debug("Getting extended info for %s"%app_info['name'])
     379                                        if pkg.get_download_size():
     380                                                app_info['size']=str(pkg.get_download_size())
     381                                        elif pkg.get_installed_size():
     382                                                app_info['size']=str(pkg.get_installed_size())
     383                                        else:
     384                                                app_info['size']="-1"
     385                                        break
     386                        else:
     387                                app_info['size']='0'
     388                #self._debug("Info for %s"%app_info)
    370389                self.partial_progress=100
    371390                return(app_info)
     
    373392
    374393        def _install_snap(self,app_info):
    375                 self._debug("Installing %s"%app_info['name'])
     394                #self._debug("Installing %s"%app_info['name'])
     395                def install(app_name,flags):
     396                        self.snap_client.install2_sync(flags,app_name.replace('.snap',''),
     397                                        None, # channel
     398                                        None, #revision
     399                                        self._callback, (None,),
     400                                        None) # cancellable
     401                        app_info['state']='installed'
     402                        self._set_status(0)
     403
    376404                if app_info['state']=='installed':
    377405                        self._set_status(4)
    378406                else:
    379407                        try:
    380                                 self.snap_client.install_sync(app_info['name'].replace('.snap',''),
    381                         None, # channel
    382                         self._callback, (None,),
    383                         None) # cancellable
    384                                 app_info['state']='installed'
    385                                 self._set_status(0)
     408                                install(app_info['name'],Snapd.InstallFlags.NONE)
    386409                        except Exception as e:
    387                                 print("Install error %s"%e)
    388                                 self._set_status(5)
    389 
    390                 self._debug("Installed %s"%app_info)
     410                                try:
     411                                        if e.code==19:
     412                                                install(app_info['name'],Snapd.InstallFlags.CLASSIC)
     413                                except Exception as e:
     414                                        #self._debug("Install error %s"%e)
     415                                        self._set_status(5)
     416                #self._debug("Installed %s"%app_info)
    391417                return app_info
    392418        #def _install_snap
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/zmdManager.py

    r7432 r8223  
    2020                if hasattr(sys,'last_value') or not (os.path.exists(self.zmd_folder)):
    2121                        #If there's an error at this point it only could be an importError caused by xmlrpc
    22                         print("ERROR!!!!")
     22                        print("ZMD support disabled")
    2323                        self.disabled=True
    2424                self.plugin_actions={'install':'zmd','pkginfo':'zmd','remove':'zmd'}
     
    3333        def set_debug(self,dbg=True):
    3434                self.dbg=dbg
    35                 self._debug ("Debug enabled")
     35                #self._debug ("Debug enabled")
    3636        #def set__debug
    3737
     
    7575        def _set_status(self,status,msg=''):
    7676                self.result['status']={'status':status,'msg':msg}
     77        #def _set_status
    7778       
    7879        def _callback(self,zmd_launcher):
     
    8990        def _install_Zmd(self,app_info):
    9091                zmd=self.zmd_folder+'/'+app_info['package']+'.zmd'
    91                 self._debug("Installing "+str(zmd))
     92                #self._debug("Installing "+str(zmd))
    9293                app_info=self._get_Zmd_Info(app_info)
    9394                if app_info['state']=='installed':
     
    9899                                try:
    99100                                        zmd_sudo=['pe',zmd]
    100                                         self._debug("executing "+str(zmd_sudo))
     101                                        #self._debug("executing "+str(zmd_sudo))
    101102                                        launched_zmd=subprocess.Popen(zmd_sudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
    102103                                        zmd_launcher=os.path.basename(zmd)
     
    107108                                        zmd_status=launched_zmd.stdout.read()
    108109                                        zmd_err=launched_zmd.stderr.read()
    109                                         self._debug("Error: "+str(zmd_err))
    110                                         self._debug("Result: "+str(zmd_status))
     110                                        #self._debug("Error: "+str(zmd_err))
     111                                        #self._debug("Result: "+str(zmd_status))
    111112                                except Exception as e:
    112                                         self._debug(str(e))
     113                                        #self._debug(str(e))
     114                                        pass
    113115                                finally:
    114116                                        app_info=self._get_Zmd_Info(app_info)
     
    123125        def _remove_Zmd(self,app_info):
    124126                zmd=app_info['package']+'.zmd'
    125                 self._debug("Removing "+str(zmd))
     127                #self._debug("Removing "+str(zmd))
    126128                os.chdir(self.zmd_folder)
    127129                sw_continue=False
     
    137139                                        packagelist=packagelist[:-1]
    138140                                        #We've the file with the packagelist, now it's time to read the list
    139                                         self._debug("Obtaining packages in : "+packagelist)
     141                                        #self._debug("Obtaining packages in : "+packagelist)
    140142                                        f2=open  (packagelist,'r')
    141143                                        for line2 in f2:
     
    143145                                                pkg=pkg.split("\t")[0]
    144146                                                pkg=pkg.replace('"','')
    145                                                 self._debug("Append to remove list: "+pkg)
     147                                                #self._debug("Append to remove list: "+pkg)
    146148                                                remove_packages.append(pkg)
    147149                                        f2.close()
     
    161163                        zmd_sudo=['gksudo',zmd_script]
    162164                        try:
    163                                 self._debug("Executing "+str(zmd_sudo))
     165                                #self._debug("Executing "+str(zmd_sudo))
    164166                                zmd_launcher=os.path.basename(zmd)
    165167                                zmd_launcher=os.path.splitext(zmd_launcher)[0]
    166168                                launched_zmd=subprocess.Popen(zmd_sudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
    167                                 self._debug("Launched")
     169                                #self._debug("Launched")
    168170                                while launched_zmd.poll() is None:
    169171                                        self._callback(zmd_launcher)
     
    173175                        except Exception as e:
    174176                                err=6
    175                                 self._debug(str(e))
    176                         self._debug("Error: "+str(zmd_err))
    177                         self._debug("Result: "+str(zmd_status))
     177                                #self._debug(str(e))
     178                        #self._debug("Error: "+str(zmd_err))
     179                        #self._debug("Result: "+str(zmd_status))
    178180                        app_info=self._get_Zmd_Info(app_info)
    179181                        if app_info['state']=='installed':
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py

    r8182 r8223  
    88import json
    99import random
     10import time
     11from queue import Queue as pool
    1012######
    1113#Ver. 1.0 of storeManager.py
     
    1921        def __init__(self,*args,**kwargs):
    2022                self.dbg=False
    21                 if 'dbg' in kwargs.keys():
     23                if 'dbg' in kwargs.keys() and self.dbg==False:
    2224                        self.dbg=kwargs['dbg']
     25                self.autostart=True
     26                if 'autostart' in kwargs.keys():
     27                        self.autostart=kwargs['autostart']
     28                        self._debug("Autostart actions: %s"%self.autostart)
    2329                self._propagate_dbg=False
    2430                self.store=None
     
    3440                                        }
    3541                self.cli_mode=[]                        #List that controls cli_mode for plugins
     42                self.autostart_actions=[]       #List with actions marked as autostart by plugins
     43                self.postaction_actions=[]      #List with actions that will be launched after other actions
     44                self.required_parms={}
    3645                self.threads={}                         #Dict with the functions that must execute each action
    3746                self.static={}                          #Dict with the functions that must execute each action
     
    5160                self.__init_plugins__(**kwargs)                 #Function that loads the plugins
    5261                self.execute_action('load')             #Initial load of the store
     62                th=threading.Thread(target=self._autostart_actions)
     63                th.start()
    5364        #def main
     65
     66        def _autostart_actions(self):
     67                if self.autostart:
     68                        for autostart_action in self.autostart_actions:
     69                                self._debug("Autostart %s"%(autostart_action))
     70                                self.execute_action(autostart_action)
    5471
    5572        ####
     
    83100                                                if target_class.disabled==None:
    84101                                                        self._debug("Plugin %s will set its status"%plugin_name)
     102                                                        pass
    85103                                                else:
    86104                                                        #Time to check if plugin is disabled or enabled by parm
     
    104122                                                        sw_cli_mode=True
    105123                                                        self._debug("Enabling cli mode for %s"%plugin_name)
     124                                        if 'autostart_actions' in target_class.__dict__.keys():
     125                                                self.autostart_actions.append(target_class.__dict__['autostart_actions'])
     126                                        if 'requires' in target_class.__dict__.keys():
     127                                                self.required_parms.update(target_class.__dict__['requires'])
     128                                        if 'postaction_actions' in target_class.__dict__.keys():
     129                                                self.postaction_actions.append({target_class:target_class.__dict__['postaction_actions']})
    106130                                except Exception as e:
    107131                                        print ("Can't initialize %s %s"%(mod,target_class))
     
    140164        def _define_functions_for_threads(self):
    141165                self.threads['load']="threading.Thread(target=self._load_Store)"
    142                 self.threads['get_info']="threading.Thread(target=self._get_App_Info,args=args,kwargs=kwargs)"
    143                 self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,args=args,kwargs=kwargs)"
    144                 self.threads['search']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
    145                 self.threads['list']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
     166                self.threads['get_info']="threading.Thread(target=self._get_App_Info,daemon=True,args=args,kwargs=kwargs)"
     167                self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,daemon=True,args=args,kwargs=kwargs)"
     168                self.threads['search']='threading.Thread(target=self._search_Store,daemon=True,args=args,kwargs=kwargs)'
     169                self.threads['list']='threading.Thread(target=self._search_Store,daemon=True,args=args,kwargs=kwargs)'
    146170#               self.threads['list']='threading.Thread(target=self._get_editors_pick,args=args,kwargs=kwargs)'
    147                 self.threads['info']='threading.Thread(target=self._search_Store,args=args,kwargs=kwargs)'
    148                 self.threads['install']='threading.Thread(target=self._install_remove_App,args=args,kwargs=kwargs)'
    149                 self.threads['remove']='threading.Thread(target=self._install_remove_App,args=args,kwargs=kwargs)'
    150                 self.threads['list_sections']='threading.Thread(target=self._list_sections,args=args,kwargs=kwargs)'
     171                self.threads['info']='threading.Thread(target=self._search_Store,daemon=True,args=args,kwargs=kwargs)'
     172                self.threads['install']='threading.Thread(target=self._install_remove_App,daemon=True,args=args,kwargs=kwargs)'
     173                self.threads['remove']='threading.Thread(target=self._install_remove_App,daemon=True,args=args,kwargs=kwargs)'
     174                self.threads['list_sections']='threading.Thread(target=self._list_sections,daemon=True,args=args,kwargs=kwargs)'
    151175                self.static['random']='self._get_editors_pick(kwargs=kwargs)'
    152176        #def _define_functions_for_threads
     
    157181        #  - action to be executed
    158182        #  - parms for the action
     183        #Action must be a kwarg but for retrocompatibility reasons we keep it as an arg
    159184        ####
    160185        def execute_action(self,action,*args,**kwargs):
    161                 #Action must be a kwarg but for retrocompatibility reasons we keep it as an arg
    162                 kwargs.update({"action":action})
     186                autostart_action=False
     187                #Check for autolaunchable actions
     188                if type(action)==type({}):
     189                        autostart_action=True
     190                        aux_action=list(action.keys())[0]
     191                        kwargs.update({"action":aux_action})
     192                        (key,value)=action[aux_action].split('=')
     193                        kwargs.update({key:value})
     194                        action=aux_action
     195                else:
     196                        kwargs.update({"action":action})
     197                        if action in self.required_parms.keys():
     198                                (key,value)=self.required_parms[action].split('=')
     199                                kwargs.update({key:value})
    163200                self._debug("Launching action: %s with args %s and kwargs %s"%(action,args,kwargs))
    164201                if self.is_action_running('load'):
    165202                        self._join_action('load')
     203                        self._debug("Total apps: %s"%str(len(self.store.get_apps())))
    166204                        self._debug("Resumed action %s"%action)
    167205                sw_track_status=False
     
    172210                                for package_type,plugin in self.plugins_registered[action].items():
    173211                                        self.action_progress[action]=0
    174                                         self.threads[action]='threading.Thread(target=self._execute_class_method(action,package_type,action).execute_action,args=[action],kwargs={kwargs})'
     212                                        if kwargs:
     213                                                kargs={}
     214                                                for arg_name in kwargs:
     215                                                        try:
     216                                                                kargs.update({arg_name:eval(kwargs[arg_name])})
     217                                                        except:
     218                                                                kargs.update({arg_name:kwargs[arg_name]})
     219                                                kwargs=kargs.copy()
     220                                        self.threads[action]='threading.Thread(target=self._execute_class_method(action,package_type).execute_action,daemon=True,args=[],kwargs=kwargs)'
    175221                                        break
    176222                                self._debug('Plugin for %s found: %s'%(action,self.plugins_registered[action]))
    177                                 self.related_actions.update({action:[action]})
     223                                if not autostart_action:
     224                                        self.related_actions.update({action:[action]})
    178225                                sw_track_status=True
    179226                if action in self.threads.keys():
     
    183230                                self.running_threads[action].join()
    184231                        try:
    185                                 if action in self.action_progress.keys():
    186                                         self.action_progress[action]=0
    187232                                self.action_progress[action]=0
    188233                                self.result[action]={}
    189                                 self.running_threads[action]=eval(self.threads[action])
     234                                self.running_threads.update({action:eval(self.threads[action])})
    190235                                self.running_threads[action].start()
     236                                if not self.running_threads[action].is_alive():
     237                                        self._debug("Relaunching!!!!!!")
     238                                        self.running_threads.update({action:eval(self.threads[action])})
     239                                        self.running_threads[action].start()
    191240                                if sw_track_status:
    192241                                        self.result[action]['status']={'status':0,'msg':''}
     
    194243                                        self.result[action]['status']={'status':-1,'msg':''}
    195244                                self._debug("Thread %s for action %s launched"%(self.running_threads[action],action))
     245                                self._debug("Thread count: %s"%(threading.active_count()))
    196246
    197247                        except Exception as e:
     
    201251                elif action in self.static.keys():
    202252                                self.action_progress[action]=0
    203                                 self.result[action]={}
    204                                 self.result[action]['data']=eval(self.static[action])
    205                                 self.result[action]['status']={'status':0,'msg':''}
     253                                self.result[action].update({'data':eval(self.static[action])})
     254                                self.result[action].update({'status':{'status':0,'msg':''}})
    206255                                self.action_progress[action]=100
    207256
    208257                else:
    209258                        self._debug("No function associated with action %s"%action)
     259                        pass
    210260        #def execute_action
    211261
    212         ####
    213         #Launch the appropiate class function
    214         #Input:
    215         #  - class action to be executed
    216         #  - parms for the action
    217         #  - parent action that demands the execution
    218         #Output
    219         #  - The class method to execute
    220         ####
    221262        def _execute_class_method(self,action,package_type,*args,launchedby=None,**kwargs):
    222263                exe_function=None
    223264                if not package_type:
    224265                        package_type="*"
    225                 if action in self.plugins_registered:
     266                if action in self.plugins_registered.keys():
    226267                        self._debug("Plugin for %s: %s"%(action,self.plugins_registered[action][package_type]))
    227                         exe_function=eval(self.plugins_registered[action][package_type]+"("+','.join(args)+")")
     268                        try:
     269                                self._debug(self.plugins_registered[action][package_type]+"("+','.join(args)+")")
     270                                exe_function=eval(self.plugins_registered[action][package_type]+"("+','.join(args)+")")
     271                        except Exception as e:
     272                                self._debug("Can't launch execute_method for class %s"%e)
     273                                pass
    228274                        if self._propagate_dbg:
    229275                                exe_function.set_debug(self.dbg)
     
    233279                else:
    234280                        self._debug("No plugin for action: %s"%action)
     281                        pass
    235282                if kwargs:
    236283                        self._debug("Parms: %s"%kwargs)
     284                        pass
    237285                return (exe_function)
    238286        #def _execute_class_method
     
    283331                        self._debug("Unable to join thread for: %s"%action)
    284332                        self._debug("Reason: %s"%e)
     333                        pass
    285334                finally:               
    286335                        if action in self.running_threads.keys():
     
    368417                        if self.is_action_running(action):
    369418                                self._join_action(action)
    370                         result[action]=None
     419                        result[action]=[]
    371420                        if action in self.result:
    372421                                if 'data' in self.result[action]:
    373422                                        result[action]=self.result[action]['data']
     423                                        if len(self.result[action]['data'])<1:
     424                                                self._debug("ERROR NO DATA")
     425                                                self._debug("ERROR NO DATA")
     426                                                self._debug("ERROR NO DATA")
     427                                                self._debug("ERROR NO DATA")
     428                                                result[action]=[""]
    374429                                else:
    375                                         result[action]=[]
     430                                        result[action]=[""]
    376431                self.lock.release()
    377432                if action in self.extra_actions.keys():
     
    418473                self.store=load_function.execute_action(action=action,store=self.store)['data']
    419474                #Once appstream is loaded load the appstream plugins for other package types (snap, appimage...)
     475                store_pool=pool()
     476                threads=[]
    420477                for package_type in self.plugins_registered[action]:
    421478                        if package_type!='*':
    422                                 load_function=self._execute_class_method(action,package_type,launchedby=None)
    423                                 self.store=load_function.execute_action(action=action,store=self.store)['data']
     479                                th=threading.Thread(target=self._th_load_store, args = (store_pool,action,package_type))
     480                                threads.append(th)
     481                                th.start()
     482                for thread in threads:
     483                        try:
     484                                thread.join()
     485                        except:
     486                                pass
     487                while store_pool.qsize():
     488                        self.store=store_pool.get()
    424489        #def _load_Store
     490
     491        def _th_load_store(self,store_pool,action,package_type):
     492                load_function=self._execute_class_method(action,package_type,launchedby=None)
     493                store_pool.put(load_function.execute_action(action=action,store=self.store)['data'])
    425494
    426495        ####
     
    523592                action='get_info'
    524593                info_function=self._execute_class_method(action,None,launchedby=launchedby)
    525                 info_applist=info_function.execute_action(self.store,action,applist)
     594                info_applist=info_function.execute_action(action,applist)
    526595                self._debug("Info collected")
    527596                return(info_applist)
     
    544613                processed=[]
    545614                for app_info in info_applist:
    546                         if channel:
    547                                 types_dict[channel]=[app_info]
    548                         else:
    549                                 available_channels=self._check_package_type(app_info)
    550                                 for package_type in available_channels:
    551                                         if app_info['component']!='':
    552                                                 if app_info['id'] in processed:
    553                                                         self._debug("App %s processed"%app_info['id'])
    554                                                         continue
    555 
    556                                         if package_type in types_dict:
    557                                                 types_dict[package_type].append(app_info)
    558                                         else:
    559                                                 types_dict[package_type]=[app_info]
    560                                         processed.append(app_info['id'])
     615                        info_function=self._execute_class_method(action,'*',launchedby=launchedby)
     616                        info_result=info_function.execute_action(action,applist=[app_info])
     617                        self._debug(info_result)
     618                        if info_result['status']['status']==0 and info_result['data'][0]['state']:
     619                                result['data'].extend(info_result['data'])
     620                        elif info_result['status']['status']==0:
     621                                app_info=info_result['data'][0]
     622                        #Get channel
     623                        available_channels=self._check_package_type(app_info)
     624                        for package_type in available_channels:
     625                                if app_info['component']!='':
     626                                        if app_info['id'] in processed:
     627                                                self._debug("App %s processed"%app_info['id'])
     628                                                continue
     629
     630                                if package_type in types_dict:
     631                                        types_dict[package_type].append(app_info)
     632                                else:
     633                                        types_dict[package_type]=[app_info]
     634                                processed.append(app_info['id'])
    561635                for package_type in types_dict:
    562636                        self._debug("Checking plugin for %s %s"%(action,package_type))
     
    647721                        if fullsearch:
    648722                                #2.- Get rest of metadata (slower)
    649                                 subordinate_action='pkginfo'
    650723                                self._debug("Target channel: %s"%target_channel)
    651724                                result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch,target_channel)
     
    658731                                                result['status']['status']=0
    659732                                else:
     733                                        self._debug(result)
    660734                                        return_msg=False
    661735                else:
     
    743817#                                                               app['appstream_id'].set_state(2)
    744818#                                                               self._debug("App state changed to available")
     819                                        for app in types_dict[package_type]:
     820                                                self._execute_postactions(action,app['package'])
    745821                                        return_msg=True
    746822                self._log("Result %s: %s"%(action,self.result[action]))
     
    773849                return(return_msg)
    774850        #def _check_package_type
     851
     852        def _execute_postactions(self,action,app):
     853                for postaction in self.postaction_actions:
     854                        for plugin,actions in postaction.items():
     855                                for key,val in actions.items():
     856                                        if action==key:
     857                                                self._debug("Application: %s"%app)
     858                                                plugin.execute_action(key,applist=app)
Note: See TracChangeset for help on using the changeset viewer.