Changeset 8180


Ignore:
Timestamp:
Oct 23, 2018, 9:16:33 AM (14 months ago)
Author:
Juanma
Message:

improved performance

Location:
lliurex-store/trunk/fuentes
Files:
3 edited

Legend:

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

    r8139 r8180  
     1lliurex-store (0.6.1) xenial; urgency=medium
     2
     3  * DebManager: add threads
     4
     5 -- Juanma Navarro Mañez <juanma1980@gmail.com>  Tue, 23 Oct 2018 09:16:05 +0200
     6
    17lliurex-store (0.6) xenial; urgency=medium
    28
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py

    r8084 r8180  
    33gi.require_version('PackageKitGlib', '1.0')
    44from gi.repository import PackageKitGlib as packagekit
     5import threading
     6from queue import Queue as pool
    57class debmanager:
    68        def __init__(self):
     
    3941        #filter=2 -> only installed app installed
    4042        def execute_action(self,action,applist,filters=1):
     43                self._debug("Executing action %s"%action)
    4144                self.progress=0
    4245                self.installer=packagekit.Client()
     
    7477                self.result['status']={'status':status,'msg':msg}
    7578
    76         def _fake_callback(self,status,typ,data=None):
     79        def _fake_callback(self,*args):
    7780                pass
    7881        #def _fake_callback
     
    8588        def _install_App(self,app):
    8689                self.return_msg=False
    87                 self._debug("Installing "+app.get_id())
     90                self._debug("Installing %s"%app.get_id())
    8891                err=0
    8992                try:
     
    9295                except Exception as e:
    9396                        print(str(e))
    94                         self._debug("Install error: "+str(e.code))
     97                        self._debug("Install error: %s"%e.code)
    9598                        err=e.code
    9699                finally:
     
    105108                        self._set_status(0)
    106109                except Exception as e:
    107                         self._debug("Remove error: " +str(e.code))
    108                         self._debug("Remove error: " +str(e))
     110                        self._debug("Remove error: %s"%e.code)
     111                        self._debug("Remove error: %s"%e)
    109112                        self._set_status(e.code)
    110113                finally:
     
    112115        #def _remove_App
    113116
     117        def _th_get_details(self,pkTask,app_info_pool,app):
     118                self._debug("Getting details for %s"%app.get_id())
     119                results=pkTask.get_details([app.get_id(),],None,self._fake_callback,None)
     120                for app_detail in results.get_details_array():
     121                        app_info_pool.put({'size':str(app_detail.get_size())})
     122                        break
     123        #def _th_get_details
     124
     125        def _th_get_depends(self,pkTask,app_info_pool,app):
     126                self._debug("Getting dependencies for %s"%app.get_id())
     127                results=pkTask.get_depends(1,[app.get_id(),],False,None,self._fake_callback,None)
     128                dependsList=[]
     129                for related_app in results.get_package_array():
     130                        dependsList.append(related_app.get_id())
     131                app_info_pool.put({'depends':dependsList})
     132        #def _th_get_depends
     133
    114134        def _get_App_Extended_Info(self,app_info,app):
    115                 self._debug("Getting dependencies for "+app.get_id())
     135                app_info['version']=app.get_version()
     136                app_info['arch']=app.get_id().split(';')[2]
    116137                pkTask=packagekit.Task()
    117138                results=[]
    118                 dependsList=[]
    119139                self._set_status(0)
    120                 try:
    121                         results=pkTask.get_depends(1,[app.get_id(),],True,None,self._fake_callback,None)
    122                 except Exception as e:
    123 #                       self._set_status(1)
    124                         print (str(e))
    125                         pass
    126                 if (results):
    127                         app_info['version']=app.get_version()
    128                         app_info['arch']=app.get_id().split(';')[2]
    129                         for related_app in results.get_package_array():
    130                                 dependsList.append(related_app.get_id())
    131                         app_info['depends']=dependsList
    132                         #app.get_version()
    133                 try:
    134                         results=pkTask.get_details([app.get_id(),],None,self._fake_callback,None)
    135                 except Exception as e:
    136 #                       self._set_status(1)
    137                         print ("ERROR %s"%e)
    138                         pass
    139                 if(results):
    140                         for app_detail in results.get_details_array():
    141                                 app_info['size']=str(app_detail.get_size())
    142                                 break
     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()
    143149                try:
    144150                        info=app.get_info()
     
    150156                        self._debug("State: "+app_info['state'])
    151157                except Exception as e:
    152                         self._debug("State: not available")
    153                                
     158                        self._debug("State: not available (%s)"%e)
     159
     160                for thread in threads:
     161                        try:
     162                                thread.join()
     163                        except:
     164                                pass
     165
     166                while app_info_pool.qsize():
     167                        data=app_info_pool.get()
     168                        app_info.update(data)
     169
    154170                return(app_info)
    155171        #def _get_App_Extended_Info
    156172
    157173        def _resolve_App(self,app_name,filters=1):
    158                 self._debug("Resolving "+app_name)
     174                self._debug("Resolving %s"%app_name)
    159175                app=None
    160176                resolvelist=[]
    161177                self.return_msg=False
    162178                try:
    163                         self._debug("Filter for resolver: "+str(filters))
     179                        self._debug("Filter for resolver: %s"%filters)
    164180                        result=self.installer.resolve(filters,[app_name,],None,self._fake_callback, None)
    165181                        resolvelist=result.get_package_array()
     
    171187                                                app_resolved=app
    172188                        if app_resolved:
    173                                 self._debug("Application "+app_resolved.get_name()+" resolved succesfully")
     189                                self._debug("Application %s resolved succesfully"%app_resolved.get_name())
    174190                                app=app_resolved
    175191                except Exception as e:
    176                         self._debug("Couldn't resolve "+app_name)
    177                         self._debug("Reason: "+str(e))
     192                        self._debug("Couldn't resolve %s"%app_name)
     193                        self._debug("Reason: %s"%e)
    178194                finally:
    179195                        self.partial_progress=100
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/snapManager.py

    r8139 r8180  
    1212import html
    1313import threading
     14from queue import Queue as pool
    1415#Needed for async find method, perhaps only on xenial
    1516wrap=Gio.SimpleAsyncResult()
     
    134135                fcache=open(self.cache_last_update,'w')
    135136                fcache.write(str(int(time.time())))
    136                 if self.cli_mode:
    137 #                       pkgs=self._search_snap("*")
    138                         pkgs=self._load_sections()
    139                 else:
    140                         pkgs=self._load_sections()
    141 #                       pkgs=self._search_snap_async("*")
     137                pkgs=self._load_sections()
    142138                self._set_status(1)
     139                store_pool=pool()
    143140                for pkg in pkgs:
    144141                        maxconnections = 10
    145142                        threads=[]
    146143                        semaphore = threading.BoundedSemaphore(value=maxconnections)
    147                         th=threading.Thread(target=self._th_load_store, args = (store,pkg,semaphore))
     144                        th=threading.Thread(target=self._th_load_store, args = (store_pool,pkg,semaphore))
    148145                        threads.append(th)
    149146                        th.start()
     147                for thread in threads:
     148                        try:
     149                                thread.join()
     150                        except:
     151                                pass
     152                while store_pool.qsize():
     153                        store.add_app(store_pool.get())
    150154                return(store)
    151155
     
    162166                                app.add_bundle(bundle)
    163167                                app.add_category("Snap")
    164                                 store.add_app(self._generate_appstream_app_from_snap(pkg))
    165                         else:
    166                                 store.add_app(self._generate_appstream_app_from_snap(pkg))
     168                                store.put(self._generate_appstream_app_from_snap(pkg))
     169                        else:
     170                                store.put(self._generate_appstream_app_from_snap(pkg))
    167171                semaphore.release()
    168172
     
    237241                        app.to_file(gioFile)
    238242                        #Fix some things in app_file...
    239                         xml_file=open(xml_path,'r')
     243                        xml_file=open(xml_path,'r',encoding='utf-8')
    240244                        xml_data=xml_file.readlines()
    241245                        xml_file.close()
    242                         count=0
    243                         xml_data[0]=xml_data[0]+"<components>\n"
    244                         xml_data[-1]=xml_data[-1]+"\n"+"</components>"
     246                        self._debug("fixing %s"%xml_path)
     247                        try:
     248                                xml_data[0]=xml_data[0]+"<components>\n"
     249                                xml_data[-1]=xml_data[-1]+"\n"+"</components>"
     250                        except:
     251                                pass
    245252                        xml_file=open(xml_path,'w')
    246253                        xml_file.writelines(xml_data)
     
    261268                return(stable_pkgs)
    262269
    263         def _search_snap_async(self,tokens):
     270        def _search_snap_async(self,tokens,force_stable=True):
    264271                self._debug("Async Searching %s"%tokens)
    265272                pkgs=None
     
    271278                while 'Snapd' not in str(type(wrap)):
    272279                        time.sleep(0.1)
    273 #               snaps,curr=self.snap_client.find_finish(wrap)
    274280                snaps=self.snap_client.find_finish(wrap)
    275281                if type(snaps)!=type([]):
     
    279285                stable_pkgs=[]
    280286                for pkg in pkgs:
    281                         if pkg.get_channel()=='stable':
     287                        if force_stable:
     288                                if pkg.get_channel()=='stable':
     289                                        stable_pkgs.append(pkg)
     290                                else:
     291                                        self._debug(pkg.get_channel())
     292                        else:
    282293                                stable_pkgs.append(pkg)
    283294                return(stable_pkgs)
    284295
    285         def _search_snap(self,tokens):
     296        def _search_snap(self,tokens,force_stable=True):
    286297                self._debug("Searching %s"%tokens)
    287298                pkg=None
    288299                pkgs=None
    289300                try:
    290 #                       pkgs,curr=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None)
    291301                        pkgs=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None)
    292302                except Exception as e:
     
    295305                stable_pkgs=[]
    296306                for pkg in pkgs:
    297                         if pkg.get_channel()=='stable':
     307                        if force_stable:
     308                                if pkg.get_channel()=='stable':
     309                                        stable_pkgs.append(pkg)
     310                                else:
     311                                        self._debug(pkg.get_channel())
     312                        else:
    298313                                stable_pkgs.append(pkg)
    299                         else:
    300                                 self._debug(pkg.get_channel())
    301314                self._debug("Done")
    302315                return(stable_pkgs)
     
    304317
    305318        def _download_file(self,url,app_name,dest_dir):
    306 #               target_file=self.icons_folder+'/'+app_name+".png"
    307319                target_file=dest_dir+'/'+app_name+".png"
    308320                if not os.path.isfile(target_file):
    309 #                       shutil.copy("/usr/share/icons/hicolor/128x128/apps/lliurex-store.png",target_file)
    310 #                       if not os.fork():
    311321                        if not os.path.isfile(target_file):
    312322                                self._debug("Downloading %s to %s"%(url,target_file))
     
    326336                                        self._debug("Reason: %s"%e)
    327337                                        target_file=''
    328 #                               os._exit(0)
    329338                return(target_file)
    330339        #def _download_file
     
    343352                        app_info['state']='available'
    344353                        if self.cli_mode:
    345                                 pkgs=self._search_snap(app_info['package'].replace('.snap',''))
    346                         else:
    347                                 pkgs=self._search_snap_async(app_info['package'].replace('.snap',''))
    348                         self._debug("Getting extended info for %s %s"%(app_info['name'],pkgs))
     354                                pkgs=self._search_snap(app_info['package'].replace('.snap',''),force_stable=False)
     355                        else:
     356                                pkgs=self._search_snap_async(app_info['package'].replace('.snap',''),force_stable=False)
     357                        self._debug("Getting extended info for %s %s"%(app_info['package'],pkgs))
    349358                if type(pkgs)==type([]):
    350359                        for pkg in pkgs:
     
    352361                                if pkg.get_download_size():
    353362                                        app_info['size']=str(pkg.get_download_size())
     363                                elif pkg.get_installed_size():
     364                                        app_info['size']=str(pkg.get_installed_size())
    354365                                else:
    355                                         app_info['size']=str(pkg.get_installed_size())
     366                                        app_info['size']="-1"
    356367                                break
    357368                else:
Note: See TracChangeset for help on using the changeset viewer.