Changeset 6645


Ignore:
Timestamp:
Jan 18, 2018, 1:34:53 PM (21 months ago)
Author:
Juanma
Message:

Added snap support. Minor changes

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

Legend:

Unmodified
Added
Removed
  • lliurex-store/trunk/fuentes/lliurex-store-cli/usr/share/lliurex-store/lliurex-store-cli.py

    r6458 r6645  
    5555                                                                else:
    5656                                                                        msg=_('available')
     57                                                                if data['updatable']:
     58                                                                        msg +=_(' (updatable)')
    5759                                                                print(_(u'Status')+': '+msg)
    5860                                                                print(_(u'Summary')+': '+data['summary'])
     
    6668                                                                print("")
    6769                                                        except Exception as e:
    68                                                                 print(e)
    69                                                                 pass
     70                                                                print("CLI: Error printing key %s"%e)
    7071                                                elif action=='search':
    7172                                                        #Only print name and summary
     
    114115        actions=[]
    115116        parms={}
    116         dbg=None
    117         bundles=None
     117        dbg=False
     118        appimage=False
     119        snap=False
    118120        args=process_Args(sys.argv)
    119         if 'debug' in args:
    120                 dbg=1
    121 
    122 #       if args.bundles:
    123 #               bundles=1
    124 
    125         '''     if args.debug:
    126                         actions.append('debug')
    127                         store.set_debug(args.debug)
    128                         parms['debug']=args.debug'''
     121        if args.debug:
     122                dbg=True
     123        if args.appimage:
     124                appimage=True
     125        if args.snap:
     126                snap=True
    129127        if args.view:
    130128                actions.append('info')
     
    139137                actions.append('remove')
    140138                parms['remove']=args.remove
     139#       if args.list:
     140#               actions.append('list')
     141#               parms['list']=args.list
    141142
    142143        actionList={'search':False,'info':False,'pkgInfo':False,'install':False,'remove':False,'list':False,'list-sections':False}
    143144        start_time=time.time()
    144         store=storeManager.StoreManager([bundles,dbg])
     145        store=storeManager.StoreManager(appimage=appimage,snap=snap,dbg=dbg,cli=True)
    145146        for action in actions:
    146147                store.execute_action(action,parms[action])
     
    175176        parser.add_argument('-i','--install',metavar='Package',help=(_(u"Install a package")))
    176177        parser.add_argument('-r','--remove',metavar='Package',help=(_(u"Remove a package")))
    177 #       parser.add_argument('--debug',action='store_true',help=(_(u"Prints debug information")))
    178 #       parser.add_argument('--bundles',action='store_true',help=(_(u"Load app bundles catalog")))
     178        parser.add_argument('--debug',action='store_true',help=(_(u"Prints debug information")))
     179        parser.add_argument('--appimage',action='store_true',help=(_(u"Load appimage catalog")))
     180        parser.add_argument('--snap',action='store_true',help=(_(u"Load snap catalog")))
     181#       parser.add_argument('--list',metavar='list',nargs='?',help=(_(u"List category")))
    179182
    180183        args=parser.parse_args()
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/appImageManager.py

    r5675 r6645  
    1010import random
    1111import time
     12import gi
     13from gi.repository import Gio
     14gi.require_version('AppStreamGlib', '1.0')
     15from gi.repository import AppStreamGlib as appstream
     16
    1217class appimagemanager:
    1318        def __init__(self):
    14                 self.dbg=0
     19                self.dbg=False
    1520                self.progress=0
     21                self.partial_progress=0
    1622                #This dict defines wich package_type relies on what action
    1723                #action=example
    1824                #package='*' (in this case all packages)
    19                 self.pluginInfo={'install':'appimage','remove':'appimage','pkginfo':'appimage'}
     25                self.plugin_actions={'install':'appimage','remove':'appimage','pkginfo':'appimage','load':'appimage'}
    2026                self.result={}
    2127                self.result['data']={}
    2228                self.result['status']={}
    23                 self.appImageFolder='/opt/bundles/appimg'
    24                 self.repoPage='https://dl.bintray.com/probono/AppImages'
     29                self.bundles_dir="/var/lib/lliurexstore/bundles"
     30                self.bundle_types=['appimg']
     31                self.appimage_dir='/opt/bundles/appimg'
     32                self.repository_url='https://dl.bintray.com/probono/AppImages'
    2533                #To get the description of an app we must go to a specific url.
    2634                #$(appname) we'll be replaced with the appname so the url matches the right one.
    2735                #If other site has other url naming convention it'll be mandatory to define it with the appropiate replacements
    28                 self.infoPage='https://bintray.com/probono/AppImages/$(appname)'
     36                self.info_url='https://bintray.com/probono/AppImages/$(appname)'
     37                self.disabled=False
    2938                self.count=0
    30                 self.disabled=True
    3139        #def __init__
    3240
    33         def set_debug(self,dbg='1'):
    34                 self.dbg=int(dbg)
     41        def set_debug(self,dbg=True):
     42                self.dbg=dbg
    3543                self._debug ("Debug enabled")
    3644        #def set_debug
    3745
    3846        def _debug(self,msg=''):
    39                 if self.dbg==1:
    40                         print ('DEBUG appImg: '+msg)
     47                if self.dbg:
     48                        print ('DEBUG appimage: '+msg)
    4149        #def debug
    4250
    4351        def register(self):
    44                 return(self.pluginInfo)
    45 
    46         def execute_action(self,action,applist=None):
    47                 self._chk_installDir()
     52                return(self.plugin_actions)
     53
     54        def enable(self,state=False):
     55                self.disable=state
     56
     57        def execute_action(self,action,applist=None,store=None):
     58                if store:
     59                        self.store=store
     60                else:
     61                        self.store=appstream.Store()
    4862                self.progress=0
    4963                self.result['status']={'status':-1,'msg':''}
    50                 self.result['data']=list(applist)
     64                self.result['data']=''
    5165                dataList=[]
    5266                if self.disabled:
    5367                        self._set_status(9)
     68                        self.result['data']=self.store
    5469                else:
    55                         for appInfo in applist:
    56                                 if action=='install':
    57                                         dataList.append(self._install_appImg(appInfo))
    58                                 if action=='remove':
    59                                         dataList.append(self._remove_appImg(appInfo))
    60                                 if action=='pkginfo':
    61                                         dataList.append(self._get_info(appInfo))
    62                         self.result['data']=list(dataList)
     70                        self._chk_installDir()
     71                        if action=='load':
     72                                self.result['data']=self._load_appimage_store(self.store)
     73                        else:
     74                                for app_info in applist:
     75                                        self.partial_progress=0
     76                                        if action=='install':
     77                                                dataList.append(self._install_appimage(app_info))
     78                                        if action=='remove':
     79                                                dataList.append(self._remove_appimage(app_info))
     80                                        if action=='pkginfo':
     81                                                dataList.append(self._get_info(app_info))
     82                                        self.progress+=int(self.partial_progress/len(applist))
     83                                self.result['data']=list(dataList)
    6384                self.progress=100
    6485                return(self.result)
     
    83104        def _chk_installDir(self):
    84105                msg_status=True
    85                 if not os.path.isdir(self.appImageFolder):
    86                         try:
    87                                 os.makedirs(self.appImageFolder)
     106                if not os.path.isdir(self.appimage_dir):
     107                        try:
     108                                os.makedirs(self.appimage_dir)
    88109                        except:
    89110                                msg_status=False
    90111                return msg_status                               
    91112
    92         def _install_appImg(self,appInfo):
    93                 appInfo=self._get_info(appInfo)
    94                 if appInfo['state']=='installed':
     113        def _install_appimage(self,app_info):
     114                app_info=self._get_info(app_info)
     115                if app_info['state']=='installed':
    95116                        self._set_status(4)
    96117                else:
    97                         appImgUrl=self.repoPage+'/'+appInfo['appImage']
    98                         self._debug("Downloading "+appImgUrl)
    99                         dest_path=self.appImageFolder+'/'+appInfo['appImage']
    100                         if appImgUrl:
     118                        appimage_url=self.repository_url+'/'+app_info['package']
     119                        self._debug("Downloading "+appimage_url)
     120                        dest_path=self.appimage_dir+'/'+app_info['package']
     121                        if appimage_url:
    101122                                try:
    102                                         with urllib.request.urlopen(appImgUrl) as response, open(dest_path, 'wb') as out_file:
     123                                        with urllib.request.urlopen(appimage_url) as response, open(dest_path, 'wb') as out_file:
    103124                                                bf=16*1024
    104125                                                acumbf=0
    105                                                 appSize=int(response.info()['Content-Length'])
     126                                                app_size=int(response.info()['Content-Length'])
    106127                                                while True:
    107                                                         if acumbf>=appSize:
     128                                                        if acumbf>=app_size:
    108129                                                            break
    109130                                                        shutil.copyfileobj(response, out_file,bf)
    110131                                                        acumbf=acumbf+bf
    111                                                         self._callback(acumbf,appSize)
     132                                                        self._callback(acumbf,app_size)
    112133                                        st = os.stat(dest_path)
    113134                                        os.chmod(dest_path, st.st_mode | 0o111)
     
    117138                        else:
    118139                                self._set_status(12)
    119                 return appInfo
    120         #def _install_appImg
    121 
    122         def _remove_appImg(self,appInfo):
    123                 self._debug("Removing "+appInfo['appImage'])
    124                 if os.path.isfile(self.appImageFolder+'/'+appInfo['appImage']):
    125                         try:
    126                                 call([self.appImageFolder+"/"+appInfo['appImage'], "--remove-appimage-desktop-integration"])
     140                return app_info
     141        #def _install_appimage
     142
     143        def _remove_appimage(self,app_info):
     144                self._debug("Removing "+app_info['package'])
     145                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
     146                        try:
     147                                call([self.appimage_dir+"/"+app_info['package'], "--remove-appimage-desktop-integration"])
    127148                        except:
    128149                                pass
    129150                        try:
    130                                 os.remove(self.appImageFolder+"/"+appInfo['appImage'])
     151                                os.remove(self.appimage_dir+"/"+app_info['package'])
    131152                                self._set_status(0)
    132153                        except:
    133154                                self._set_status(6)
    134                 return(appInfo)
    135         #def _remove_appImg
    136 
    137         def _get_info(self,appInfo):
    138                 appInfo['state']='available'
    139                 if os.path.isfile(self.appImageFolder+'/'+appInfo['appImage']):
    140                         appInfo['state']='installed'
     155                return(app_info)
     156        #def _remove_appimage
     157
     158        def _get_info(self,app_info):
     159                app_info['state']='available'
     160                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
     161                        app_info['state']='installed'
     162                #Get size
     163                appimage_url=self.repository_url+'/'+app_info['package']
     164                dest_path=self.appimage_dir+'/'+app_info['package']
     165                if appimage_url:
     166                        try:
     167                                with urllib.request.urlopen(appimage_url) as response:
     168                                        app_info['size']=(response.info()['Content-Length'])
     169                        except:
     170                                app_info['size']=0
    141171                self._set_status(0)
    142                 return(appInfo)
     172                self.partial_progress=100
     173                return(app_info)
    143174        #def _get_info
    144175
     176        def _load_appimage_store(self,store):
     177                self._download_bundles_catalogue()
     178                if os.path.exists(self.bundles_dir):
     179                        for bundle_type in self.bundle_types:
     180                                self._debug("Loading %s catalog"%bundle_type)
     181                                store=self._generic_file_load(self.bundles_dir+'/'+bundle_type,store)
     182                return(store)
     183        #def load_bundles_catalog(self)
     184       
     185        def _generic_file_load(self,target_path,store):
     186                icon_path='/usr/share/icons/hicolor/128x128'
     187                if not os.path.isdir(target_path):
     188                        os.makedirs(target_path)
     189                files=os.listdir(target_path)
     190                for target_file in os.listdir(target_path):
     191                        if target_file.endswith('appdata.xml'):
     192                                store_path=Gio.File.new_for_path(target_path+'/'+target_file)
     193                                self._debug("Adding file "+target_path+'/'+target_file)
     194                                try:
     195                                        store.from_file(store_path,icon_path,None)
     196                                except Exception as e:
     197                                        self._debug("Couldn't add file "+target_file+" to store")
     198                                        self._debug("Reason: "+str(e))
     199                return(store)
     200        #def _generic_file_load
     201
     202        def _download_bundles_catalogue(self):
     203                CURSOR_UP='\033[F'
     204                ERASE_LINE='\033[K'
     205                content=''
     206                applist=[]
     207                progress_bar="#"
     208                repositories_list={'appimg':['https://dl.bintray.com/probono/AppImages']}
     209                #For get the description of an app we must go to a specific url.
     210                #$(appname) we'll be replaced with the appname so the url matches the right one.
     211                #If other site has other url naming convention it'll be mandatory to define it with the appropiate replacements
     212                info_list={'appimg':'https://bintray.com/probono/AppImages/$(appname)'}
     213                self.descriptions_dict={}
     214
     215                for repo_type,repo_types in repositories_list.items():
     216                        info_url=info_list[repo_type]
     217                        outdir=self.bundles_dir+'/'+repo_type+'/'
     218                        if self._chk_bundle_dir(outdir):
     219                                for repo in repo_types:
     220                                        self._debug(("Fetching repo %s")%(repo))
     221#                                       print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     222#                                       progress_bar=progress_bar+"#"
     223#                                       print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     224                                        applist=self._generate_applist(self._fetch_repo(repo))
     225#                                       progress_bar=progress_bar+"##"
     226#                                       print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     227                                        self._debug("Processing info...")
     228                                        self._th_generate_xml_catalog(applist,outdir,info_url,repo_type,progress_bar)
     229                                        self._debug("Fetched repo "+repo)
     230#                                       print (("Removing old entries..."))
     231                                        self._clean_bundle_catalogue(applist,outdir)
     232                        else:
     233                                        self._debug("appImage catalogue could not be fetched: Permission denied")
     234                return(True)
     235        #def _download_bundles_catalogue
     236
     237        def _chk_bundle_dir(self,outdir):
     238                msg_status=True
     239                if not os.path.isdir(outdir):
     240                        try:
     241                                os.makedirs(outdir)
     242                        except:
     243                                msg_status=False
     244                return(os.access(outdir,os.W_OK|os.R_OK|os.X_OK|os.F_OK))
     245        #def _chk_bundle_dir
     246
     247        def _fetch_repo(self,repo):
     248                with urllib.request.urlopen(repo) as f:
     249                        content=(f.read().decode('utf-8'))
     250                return(content)
     251        #def _fetch_repo
     252
     253        def _generate_applist(self,content):
     254                garbage_list=[]
     255                applist=[]
     256                garbage_list=content.split(' ')
     257                for garbage_line in garbage_list:
     258                        if garbage_line.endswith('AppImage"'):
     259                                app=garbage_line.replace('href=":','')
     260                                applist.append(app.replace('"',''))
     261                return(applist)
     262        #def _generate_applist
     263
     264        def _th_generate_xml_catalog(self,applist,outdir,info_url,repo_type,progress_bar=''):
     265                CURSOR_UP='\033[F'
     266                ERASE_LINE='\033[K'
     267                maxconnections = 10
     268                semaphore = threading.BoundedSemaphore(value=maxconnections)
     269                random_applist = list(applist)
     270                random.shuffle(random_applist)
     271                len_applist=len(random_applist)
     272                inc=30/len_applist
     273#               print (CURSOR_UP)
     274                for app in random_applist:
     275                        th=threading.Thread(target=self._th_write_xml, args = (app,outdir,info_url,semaphore,inc))
     276                        th.start()
     277#               os.system('setterm -cursor off')
     278                while threading.active_count()>2: #Discard both main and own threads
     279                        for i in range(len(progress_bar),int(self.progress)):
     280                                progress_bar='#'+progress_bar
     281#                       print (CURSOR_UP)
     282#                       print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     283#               os.system('setterm -cursor on')
     284        #def _th_generate_xml_catalog
     285
     286        def _th_write_xml(self,app,outdir,info_url,semaphore,inc):
     287                semaphore.acquire()
     288                lock=threading.Lock()
     289                name_splitted=app.split('-')
     290                name=name_splitted[0]
     291                version=name_splitted[1]
     292                arch=name_splitted[2]
     293                filename=outdir+app.lower().replace('appimage',"appdata.xml")
     294                self._debug("checking if we need to download "+filename)
     295                if not os.path.isfile(filename):
     296                        self._write_xml_file(filename,app,name,version,info_url,lock)
     297                with lock:
     298                        self.progress=self.progress+inc
     299                semaphore.release()
     300        #def _th_write_xml
     301
     302        def _write_xml_file(self,filename,app,name,version,info_url,lock):
     303                        self._debug("Generating "+app+" xml")
     304                        f=open(filename,'w')
     305                        f.write('<?xml version="1.0" encoding="UTF-8"?>'+"\n")
     306                        f.write("<components version=\"0.10\">\n")
     307                        f.write("<component  type=\"desktop-application\">\n")
     308                        f.write("  <id>"+app.lower()+"</id>\n")
     309                        f.write("  <pkgname>"+app+"</pkgname>\n")
     310                        f.write("  <name>"+name+"</name>\n")
     311                        f.write("  <metadata_license>CC0-1.0</metadata_license>\n")
     312                        f.write("  <provides><binary>"+app+"</binary></provides>\n")
     313                        f.write("  <releases>\n")
     314                        f.write("  <release version=\""+version+"\" timestamp=\"1408573857\"></release>\n")
     315                        f.write("  </releases>\n")
     316                        f.write("  <launchable type=\"desktop-id\">"+name+".desktop</launchable>\n")
     317                        with lock:
     318                                try:
     319                                        if name in self.descriptions_dict.keys():
     320                                                description=self.descriptions_dict[name]
     321                                        else:
     322                                                description=self._get_description(name,info_url)
     323                                                self.descriptions_dict.update({name:description})
     324                                except:
     325                                        description=''
     326                        summary=' '.join(list(description.split(' ')[:8]))
     327                        description="This is an AppImage bundle of app "+name+". It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully."
     328                        if not summary:
     329                                summary=' '.join(list(description.split(' ')[:8]))
     330                        f.write("  <description><p></p><p>"+description+"</p></description>\n")
     331                        f.write("  <summary>"+summary+"...</summary>\n")
     332                        f.write("  <bundle type=\"appimage\">"+app+"</bundle>\n")
     333                        f.write("  <keywords>\n")
     334                        f.write("       <keyword>"+name+"</keyword>\n")
     335                        f.write("       <keyword>appimage</keyword>\n")
     336                        f.write("  </keywords>\n")
     337                        f.write("  <categories>\n")
     338                        f.write("       <category>AppImage</category>\n")
     339#                       f.write("       <category>GTK</category>\n")
     340                        f.write("  </categories>\n")
     341                        f.write("<icon type=\"cached\">"+name+"_"+name+".png</icon>\n")
     342                        f.write("</component>\n")
     343                        f.write("</components>\n")
     344                        f.close()
     345        #def _write_xml_file
     346
     347        def _get_description(self,app_name,info_url):
     348                desc=''
     349                if '$(appname)' in info_url:
     350                        info_url=info_url.replace('$(appname)',app_name)
     351                self._debug("Getting description from "+info_url)
     352                try:
     353                        with urllib.request.urlopen(info_url) as f:
     354                                content=(f.read().decode('utf-8'))
     355                                soup=BeautifulSoup(content,"html.parser")
     356                                description_div=soup.findAll('div', attrs={ "class" : "description-text"})
     357                        if len(description_div)>0:
     358                                desc=description_div[0].text
     359                                desc=desc.replace(':','.')
     360                                desc=desc.replace('&','&amp;')
     361                except Exception as e:
     362                        print("Can't get description from "+info_url)
     363                        print(str(e))
     364                        pass
     365                return(desc)
     366        #def _get_description
     367
     368        def _clean_bundle_catalogue(self,applist,outdir):
     369                xml_files_list=[]
     370                applist=[item.lower() for item in applist]
     371                for xml_file in os.listdir(outdir):
     372                        if xml_file.endswith('appdata.xml'):
     373                                xml_files_list.append(xml_file.lower().replace('appdata.xml','appimage'))
     374       
     375                if xml_files_list:
     376                        xml_discard_list=list(set(xml_files_list).difference(applist))
     377                        for discarded_file in xml_discard_list:
     378                                os.remove(outdir+'/'+discarded_file.replace('appimage','appdata.xml'))
     379        #def _clean_bunlde_catalogue
     380
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py

    r5187 r6645  
    66        def __init__(self):
    77                self.installer=''
    8                 self.dbg=0
     8                self.dbg=False
    99                self.pkgList=[]
    1010                self.result=[]
    1111                self.progress=0
    12                 self.partialProgress=0
    13                 #self.pluginInfo=['install','deb','remove','deb','pkginfo','deb','remove','zmd']
    14                 self.pluginInfo={'install':'deb','remove':'deb','pkginfo':'deb'}
     12                self.partial_progress=0
     13                self.plugin_actions={'install':'deb','remove':'deb','pkginfo':'deb'}
    1514                self.result={}
    1615                self.result['data']={}
     
    1918        #def __init__
    2019
    21         def set_debug(self,dbg='1'):
    22                 self.dbg=int(dbg)
     20        def set_debug(self,dbg=True):
     21                self.dbg=dbg
    2322                self._debug ("Debug enabled")
    2423        #def set_debug
    2524
    2625        def _debug(self,msg=''):
    27                 if self.dbg==1:
     26                if self.dbg:
    2827                        print ('DEBUG Deb: '+str(msg))
    2928        #def debug
     
    3534
    3635        def register(self):
    37                 return(self.pluginInfo)
     36                return(self.plugin_actions)
    3837        #def register
    3938
     
    4746                processedPkg=[]
    4847                #1.- If the app doesn't exist cancel the action
    49                 for appInfo in applist:
    50                         if appInfo['package'] not in processedPkg:
    51                                 processedPkg.append(appInfo['package'])
     48                for app_info in applist:
     49                        if app_info['package'] not in processedPkg:
     50                                processedPkg.append(app_info['package'])
    5251                                filters=1
    5352                                if action=='remove':
    5453                                        filters=2
    55                                 app=self._resolve_App(appInfo['package'],filters)
     54                                app=self._resolve_App(app_info['package'],filters)
    5655                                if app:
    5756                                        if action=='install':
    58                                                 self._log("Installing "+appInfo['package'])
     57                                                self._log("Installing "+app_info['package'])
    5958                                                self._install_App(app)
    60                                                 self.result['data'].append({'package':appInfo['package']})
     59                                                self.result['data'].append({'package':app_info['package']})
    6160                                        if action=='remove':
    62                                                 self._log("Removing "+appInfo['package'])
     61                                                self._log("Removing "+app_info['package'])
    6362                                                self._remove_App(app)
    64                                                 self.result['data'].append({'package':appInfo['package']})
     63                                                self.result['data'].append({'package':app_info['package']})
    6564                                        if action=='pkginfo':
    66                                                 self._log("Looking "+appInfo['package'])
    67                                                 self.result['data'].append(self._get_App_Extended_Info(appInfo,app))
    68                                 self.progress=self.progress+(self.partialProgress/self.count)
     65                                                self._log("Looking "+app_info['package'])
     66                                                self.result['data'].append(self._get_App_Extended_Info(app_info,app))
     67                                self.progress=self.progress+(self.partial_progress/self.count)
    6968                self.progress=100
    7069                return(self.result)
     
    7978
    8079        def _callback(self,status,typ,data=None):
    81                 self.partialProgress=status.props.percentage
    82                 self.progress=self.partialProgress/self.count
     80                self.partial_progress=status.props.percentage
     81                self.progress=self.partial_progress/self.count
    8382        #def _callback
    8483
     
    9594                        err=e.code
    9695                finally:
    97                         self.partialProgress=100
     96                        self.partial_progress=100
    9897                self._set_status(err)
    9998                return err
     
    109108                        self._set_status(e.code)
    110109                finally:
    111                         self.partialProgress=100
     110                        self.partial_progress=100
    112111        #def _remove_App
    113112
    114         def _get_App_Extended_Info(self,appInfo,app):
     113        def _get_App_Extended_Info(self,app_info,app):
    115114                self._debug("Getting dependencies for "+app.get_id())
    116115                pkTask=packagekit.Task()
     
    125124                        pass
    126125                if (results):
    127                         appInfo['version']=app.get_version()
    128                         appInfo['arch']=app.get_id().split(';')[2]
     126                        app_info['version']=app.get_version()
     127                        app_info['arch']=app.get_id().split(';')[2]
    129128                        for related_app in results.get_package_array():
    130129                                dependsList.append(related_app.get_id())
    131                         appInfo['depends']=dependsList
     130                        app_info['depends']=dependsList
    132131                        #app.get_version()
    133132                try:
     
    135134                except Exception as e:
    136135#                       self._set_status(1)
    137                         print (str(e))
     136                        print ("ERROR %s"%e)
    138137                        pass
    139138                if(results):
    140139                        for app_detail in results.get_details_array():
    141                                 appInfo['size']=str(app_detail.get_size())
     140                                app_info['size']=str(app_detail.get_size())
    142141                                break
    143142                try:
    144143                        info=app.get_info()
    145                         appInfo['state']=info.to_string(info)
    146                         self._debug("State: "+appInfo['state'])
    147                 except:
     144                        state=info.to_string(info)
     145                        if state!=app_info['state'] and app_info['state']=='installed':
     146                                app_info['updatable']=1
     147                        else:
     148                                app_info['state']=state
     149                        self._debug("State: "+app_info['state'])
     150                except Exception as e:
    148151                        self._debug("State: not available")
    149                         pass
    150152                               
    151                 return(appInfo)
     153                return(app_info)
    152154        #def _get_App_Extended_Info
    153155
    154         def _get_App_Info(self,appInfo,app,appsCount=0): #DEPRECATED
    155                 try:
    156                         info=app.get_info()
    157                         appInfo['status']=info.to_string(info)
    158                         self._debug("Status: "+appInfo['status'])
    159                 except:
    160                         self._debug("Status: not available")
    161                         pass
    162                 #Only search dependencies if there's only one package on the package queue
    163                 if appsCount==1:
    164                         self._debug("loading extended info")
    165                         appInfo=self._get_App_Extended_Info(appInfo,app)
    166                 self.partialProgress=100
    167                 self.result.append(appInfo)
    168 #               self.result['data'].update({appInfo['package']:appInfo})
    169                 self._set_status(0)
    170                 return(appInfo)
    171         #def _get_App_Info
    172 
    173         def _resolve_App(self,appName,filters=False):
    174                 self._debug("Resolving "+appName)
     156        def _resolve_App(self,app_name,filters=1):
     157                self._debug("Resolving "+app_name)
    175158                app=None
    176159                resolvelist=[]
    177160                self.return_msg=False
    178                 if not filters:
    179                         filters=1
    180161                try:
    181162                        self._debug("Filter for resolver: "+str(filters))
    182                         result=self.installer.resolve(filters,[appName,],None,self._fake_callback, None)
     163                        result=self.installer.resolve(filters,[app_name,],None,self._fake_callback, None)
    183164                        resolvelist=result.get_package_array()
    184                         resolvedApp=resolvelist[0]
     165                        app_resolved=resolvelist[0]
    185166                        #resolver bug: filters not work so if we want to remove an app first we must get the installed version...
    186167                        if filters==2:
    187168                                for app in resolvelist:
    188169                                        if (str(app.get_info()).find('PK_INFO_ENUM_INSTALLED')!=-1):
    189                                                 resolvedApp=app
    190                         if resolvedApp:
    191                                 self._debug("Application "+resolvedApp.get_name()+" resolved succesfully")
    192                                 app=resolvedApp
     170                                                app_resolved=app
     171                        if app_resolved:
     172                                self._debug("Application "+app_resolved.get_name()+" resolved succesfully")
     173                                app=app_resolved
    193174                except Exception as e:
    194                         self._debug("Couldn't resolve "+appName)
     175                        self._debug("Couldn't resolve "+app_name)
    195176                        self._debug("Reason: "+str(e))
    196177                finally:
    197                         self.partialProgress=100
     178                        self.partial_progress=100
    198179                return(app)
    199180        #def _resolve_App
    200        
     181
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/example.py

    r5133 r6645  
    55class example:
    66        def __init__(self):
    7                 self.dbg=0
     7                self.dbg=False
    88                self.progress=0
    99                #This dict defines wich package_type relies on what action
     
    1212                #action=example
    1313                #package='*' (in this case all package_types. It could be "deb", "zmd" or whatever package type)
    14                 self.pluginInfo={'example':'*'}
     14                self.plugin_actions={'example':'*'}
     15                #This switch enables cli_mode for the plugin, just in case some function difers from the gui mode
     16                self.cli_mode=False
     17                #This one controls if the plugin is enabled or not
     18                #It could be activated from two ways:
     19                # - storeManager having a parameter with name=package_type (simply add it to the arg list passed when invoking storeManager)
     20                # - Internal failure controls (see zmdManager for an example)
     21                #This example plugin is disabled by default
     22                self.disabled=True
    1523        #def __init__
    1624       
    17         #public function that sets the debug mode. If we execute storeManager in debug mode all plugins will be launched in this mode.
    18         def set_debug(self,dbg='1'):
     25        #public function that sets the debug mode. If we execute storeManager in debug mode all plugins will be launched in this mode if propaate_debug==True
     26        def set_debug(self,dbg=True):
    1927                self.dbg=int(dbg)
    2028                self.debug ("Debug enabled")
     
    2230
    2331        def _debug(self,msg=''):
    24                 if self.dbg==1:
     32                if self.dbg:
    2533                        print ('DEBUG Example: '+msg)
    2634        #def debug
    2735
    28         #public function accessed by sotremanager in order to register the plugin and its actions
     36        #public function accessed by storemanager in order to register the plugin and its actions
    2937        def register(self):
    3038                #This function MUST return the dict with the action:package_type pair
    31                 #In this example it returns nothing
    32                 self.pluginInfo={}
    33                 return(self.pluginInfo)
     39                return(self.plugin_actions)
    3440
    3541        #storeManager calls this method when launchs an action.
     
    4248                self.result['status']={'status':-1,'msg':''}
    4349                self.result['data']=''
    44                 for app in applist:
    45                         if action=='example':
    46                                 datalist.append(self._exec_example(app))
    47                 self.result['data']=list(dataList)
    48                 self.progress=100 #When all actions are launched we must assure that progress=100.
     50                if self.disabled:
     51                        self._set_status(9)
     52                else:
     53                        for app in applist:
     54                                if action=='example':
     55                                        datalist.append(self._exec_example(app))
     56                        self.result['data']=list(dataList)
     57                        self.progress=100 #When all actions are launched we must assure that progress=100.
    4958                return(self.result)
    5059
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/infoManager.py

    r5674 r6645  
    33class infomanager:
    44        def __init__(self):
    5                 self.dbg=0
     5                self.dbg=True
    66                self.pluginInfo={'get_info':'*'}
    77#               self.pluginInfo={'info':'*','get_info':'*'}
     
    1414        #def __init__
    1515
    16         def set_debug(self,dbg='1'):
    17                 self.dbg=int(dbg)
     16        def set_debug(self,dbg=True):
     17                self.dbg=dbg
    1818                self._debug ("Debug enabled")
    1919        #def set__debug
    2020
    2121        def _debug(self,msg=''):
    22                 if self.dbg==1:
     22                if self.dbg:
    2323                        print ('DEBUG Info: '+str(msg))
    2424        #def _debug
     
    4848        def _set_locale(self):
    4949                if locale.getdefaultlocale()[0]=="ca_ES":
    50                         self.locale=['ca_ES@valencia','ca@valencia','qcv','ca','ca_ES','es_ES','es','en_US','en','C']
     50                        self.locale=['ca_ES@valencia','ca@valencia','qcv','ca','ca_ES','es_ES','es','en_US','en_GB','en','C']
    5151                else:
    5252                        if locale.getdefaultlocale()[0]=="es_ES":
    53                                 self.locale=['es_ES','es','ca_ES@valencia','ca@valencia','qcv','ca','ca_ES','en_US','en','C']
    54                         else:
    55                                 self.locale=[locale.getlocale()[0],'en_US','en','ca_ES@valencia','ca@valencia','qcv','ca','es_ES','es','C']
     53                                self.locale=['es_ES','es','ca_ES@valencia','ca@valencia','qcv','ca','ca_ES','en_US','en_GB','en','C']
     54                        else:
     55                                self.locale=[locale.getlocale()[0],'en_US','en_GB','en','ca_ES@valencia','ca@valencia','qcv','ca','es_ES','es','C']
    5656        #def _set_locale
    5757
     
    6464                        if app.get_id():
    6565                                appInfo['id']=app.get_id()
    66                                 if not appInfo['id'].endswith('desktop'):
    67                                         appInfo['id']+='.desktop'
    6866                        for localeItem in self.locale:
    6967                                if app.get_name(localeItem):
     
    8179                                appInfo['license']=app.get_project_license()
    8280                        else:
     81                                appInfo['license']='other/restricted'
    8382                                orig=app.get_origin()
    8483                                if orig:
    8584                                        if '-main' in orig or '-universe' in orig:
    8685                                                appInfo['license']='open source'
    87                                         else:
    88                                                 appInfo['license']='propietary/restricted'
    8986                        for localeItem in self.locale:
    9087                                if app.get_comment(localeItem):
     
    156153                                if 'embed' not in appInfo['video']:
    157154                                        appInfo['video']=appInfo['video'].replace('watch?v=','embed/')
     155                        #F***g appstream returns unknown for all the possible types
     156#                       if app.get_bundle_default():
     157#                               appInfo['bundle']=app.get_bundle_default().get_kind()
     158                        #Fix F***g appstream returns unknown for all the possible types
     159                        #ID must contain bundle type as last field
    158160                        for bundle in app.get_bundles():
    159161                                if bundle.get_kind()==0:
    160                                 #F***g appstream returns unknown for all the possible types
    161                                         if bundle.get_id().endswith('AppImage'):
    162                                                 appInfo['appImage']=bundle.get_id()
    163                                         else:
     162                                        kind=bundle.get_id().split('.')[-1]
     163                                        appInfo['bundle']=kind.lower()
     164                                        if kind.lower=='sh':
    164165                                                appInfo['installerUrl']=bundle.get_id()
    165                                 if bundle.get_kind()==6:
    166                                         appInfo['appImage']=bundle.get_id()
    167166                        applistInfo.append(appInfo)
    168167                        self._callback_progress()
     
    193192                'extraInfo':'',\
    194193                'size':'',\
    195                 'appImage':'',\
     194                'bundle':'',\
     195                'updatable':'',\
    196196                }
    197197                return(appInfo)
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/loadStore.py

    r6547 r6645  
    1717class loadstore:
    1818        def __init__(self):
    19                 self.dbg=0
    20                 self.pluginInfo={'load':'*','load_bundles':'*'}
     19                self.dbg=False
     20                self.plugin_actions={'load':'*'}
    2121                self.store=''
    2222                self.progress=0
    2323                self.error=0
    24                 self.bundleDir="/var/lib/lliurexstore/bundles"
    25                 self.bundleTypes=['appimg']
    26                 self.zmdCatalogueDir='/var/lib/lliurexstore/zmds'
     24                self.zmd_store_dir='/var/lib/lliurexstore/zmds'
     25                self.result={}
     26                self.result['data']={}
     27                self.result['status']={}
    2728        #def __init__
    2829
    29         def set_debug(self,dbg='1'):
    30                 self.dbg=int(dbg)
     30        def set_debug(self,dbg=True):
     31                self.dbg=dbg
    3132                self._debug ("Debug enabled")
    3233        #def set_debug
    3334
    3435        def _debug(self,msg=''):
    35                 if self.dbg==1:
     36                if self.dbg:
    3637                        print ('DEBUG Load: '+str(msg))
    3738        #def _debug
    3839
    3940        def register(self):
    40                 return(self.pluginInfo)
     41                return(self.plugin_actions)
    4142        #def register
    4243
     
    5152                if action=='load_bundles':
    5253                        self._load_store(self.store,loadBundles=True)
     54#               self.progress=100
     55                self.result['data']=self.store
    5356                self.progress=100
    54                 return (self.store)
     57                return(self.result)
     58#               return (self.store)
    5559        #def execute_action
    5660
     
    6064
    6165        def _load_store(self,store,loadBundles=False):
    62                 iconPath='/usr/share/icons/hicolor/128x128'
     66                icon_dir='/usr/share/icons/hicolor/128x128'
    6367                flags=[appstream.StoreLoadFlags.APP_INFO_SYSTEM,appstream.StoreLoadFlags.APP_INSTALL,appstream.StoreLoadFlags.APP_INFO_USER,appstream.StoreLoadFlags.DESKTOP,appstream.StoreLoadFlags.APPDATA,appstream.StoreLoadFlags.ALLOW_VETO]
    6468                for flag in flags:
     
    7175                store=self.load_zmds_catalog(store)
    7276                store=self._sanitize_store(store)
    73                 if loadBundles:
    74                         if self._download_bundles_catalogue():
    75                                 store=self.load_bundles_catalog(store)
    7677                self.store=store
    7778                return(store)
    7879        #def load_store
    7980
    80         def load_bundles_catalog(self,store):
    81                 if os.path.exists(self.bundleDir):
    82                         for bundleType in self.bundleTypes:
    83                                 store=self._generic_file_load(self.bundleDir+'/'+bundleType,store)
    84                 return(store)
    85         #def load_bundles_catalog(self)
    86 
    8781        def load_zmds_catalog(self,store):
    88                 if os.path.exists(self.zmdCatalogueDir):
    89                         store=self._generic_file_load(self.zmdCatalogueDir,store)
     82                if os.path.exists(self.zmd_store_dir):
     83                        store=self._generic_file_load(self.zmd_store_dir,store)
    9084                return(store)
    9185        #def load_zmds_catalog(self)
    9286
    93         def _generic_file_load(self,filesDir,store):
    94                 iconPath='/usr/share/icons/hicolor/128x128'
    95                 files=os.listdir(filesDir)
    96                 for appFile in os.listdir(filesDir):
    97                         if appFile.endswith('appdata.xml'):
    98                                 storePath=Gio.File.new_for_path(filesDir+'/'+appFile)
    99                                 self._debug("Adding file "+filesDir+'/'+appFile)
     87        def _generic_file_load(self,target_dir,store):
     88                icon_dir='/usr/share/icons/hicolor/128x128'
     89                files=os.listdir(target_dir)
     90                for target_file in os.listdir(target_dir):
     91                        if target_file.endswith('appdata.xml'):
     92                                store_file=Gio.File.new_for_path(target_dir+'/'+target_file)
     93                                self._debug("Adding file "+target_dir+'/'+target_file)
    10094                                try:
    101                                         store.from_file(storePath,iconPath,None)
     95                                        store.from_file(store_file,icon_dir,None)
    10296                                except Exception as e:
    103                                         self._debug("Couldn't add file "+appFile+" to store")
     97                                        self._debug("Couldn't add file "+target_file+" to store")
    10498                                        self._debug("Reason: "+str(e))
    10599                return(store)
    106100       
    107101        def _parse_desktop(self,store): #DEPRECATED. Loads the apps from the available desktop files
    108                 desktopDir='/usr/share/applications'
     102                desktop_dir='/usr/share/applications'
    109103                applist=[]
    110                 for desktopFile in os.listdir(desktopDir):
    111                         if desktopFile.endswith('desktop'):
     104                for desktop_file in os.listdir(desktop_dir):
     105                        if desktop_file.endswith('desktop'):
    112106                                a=appstream.App()
    113107                                try:
    114                                         a.parse_file(desktopDir+'/'+desktopFile,16)
     108                                        a.parse_file(desktop_dir+'/'+desktop_file,16)
    115109                                        a.set_priority(0)
    116110                                        for veto in a.get_vetos():
    117111                                                a.remove_veto(veto)
    118112                                        store.add_app(a)
    119                                         self._debug("Adding app from desktop "+desktopFile)
     113                                        self._debug("Adding app from desktop "+desktop_file)
    120114                                except:
    121115                                        pass
     
    125119        def _sanitize_store(self,store):
    126120                applist=store.get_apps()
    127                 uniqDict={}
    128                 lliurexApps={}
    129                 zmdList=[]
     121                tmp_store_apps={}
     122                lliurex_apps={}
     123                zmd_apps=[]
    130124                for app in applist:
    131125                        #Zomandos get max priority
     
    133127                                self._debug("Prioritize zmd "+str(app.get_id()))
    134128                                app.set_priority(400)
    135                                 lliurexApps.update({app.get_id_filename():app})
    136                                 id=str(app.get_id_filename()).replace('zero-lliurex-','')
    137                                 zmdList.append(id)
     129                                lliurex_apps.update({app.get_id_filename():app})
     130                                id_app=str(app.get_id_filename()).replace('zero-lliurex-','')
     131                                zmd_apps.append(id_app)
    138132                        #Prioritize Lliurex apps
    139133                        elif app.has_category('Lliurex'):
    140134                                self._debug("Prioritize app "+str(app.get_id()))
    141135                                app.set_priority(200)
    142                                 lliurexApps.update({app.get_id_filename():app})
     136                                lliurex_apps.update({app.get_id_filename():app})
    143137                        elif str(app.get_origin()).find('lliurex')>=0:
    144138                                self._debug("Prioritize app "+app.get_id())
    145139                                app.set_priority(100)
    146                                 lliurexApps.update({app.get_id_filename():app})
     140                                lliurex_apps.update({app.get_id_filename():app})
    147141                        else:
    148142                                app.set_priority(0)
    149                                 if app.get_id_filename() in lliurexApps.keys():
     143                                if app.get_id_filename() in lliurex_apps.keys():
    150144                                        self._debug("Mergin app "+str(app.get_id())+" as is in Lliurex")
    151                                         lliurexApps[app.get_id_filename()].subsume_full(app,appstream.AppSubsumeFlags.BOTH_WAYS)
     145                                        lliurex_apps[app.get_id_filename()].subsume_full(app,appstream.AppSubsumeFlags.BOTH_WAYS)
    152146                                        store.remove_app(app)
    153147                        #Remove apps whitout pkgname
     
    161155                        #Unlike gnome-store we'll try to compare the info of the package in order of discard only the "part-of" packages
    162156                        pkg=app.get_pkgname_default()
    163                         if pkg in uniqDict.keys():
     157                        if pkg in tmp_store_apps.keys():
    164158                                fn=app.get_id_no_prefix()
    165                                 self._debug("Comparing "+fn+" with "+uniqDict[pkg]['fn'])
    166                                 if fn != uniqDict[pkg]['fn']:
     159                                self._debug("Comparing "+fn+" with "+tmp_store_apps[pkg]['fn'])
     160                                if fn != tmp_store_apps[pkg]['fn']:
    167161                                        if fn != pkg and ".desktop" not in fn:
    168162                                                self._debug("Removed duplicated "+app.get_id())
    169163                                                store.remove_app(app)
    170164                                        else:
    171                                                 self._debug("Removed duplicated "+uniqDict[pkg]['app'].get_id())
    172                                                 store.remove_app(uniqDict[pkg]['app'])
    173                                                 uniqDict.update({pkg:{'fn':app.get_id_no_prefix(),'app':app}})
     165                                                self._debug("Removed duplicated "+tmp_store_apps[pkg]['app'].get_id())
     166                                                store.remove_app(tmp_store_apps[pkg]['app'])
     167                                                tmp_store_apps.update({pkg:{'fn':app.get_id_no_prefix(),'app':app}})
    174168                        elif pkg:
    175169#                               self._debug("Adding "+app.get_id_filename()+" to uniq dict")
    176                                 uniqDict.update({pkg:{'fn':app.get_id_filename(),'app':app}})
     170                                tmp_store_apps.update({pkg:{'fn':app.get_id_filename(),'app':app}})
    177171                #Delete zomando-related debs
    178                 store=self._purge_zomandos(zmdList,store)
     172                store=self._purge_zomandos(zmd_apps,store)
    179173                #Check the blacklist
    180174                store=self._apply_blacklist(store)
     
    182176        #def _sanitize_store
    183177
    184         def _purge_zomandos(self,zmdList,store):
    185                 for appId in zmdList:
    186                         self._debug("Searching debs related to "+appId)
    187                         purgeList=store.get_apps_by_id(appId)
    188                         purgeList.extend(store.get_apps_by_id(appId+".desktop"))
    189                         for purgeApp in purgeList:
    190                                 if purgeApp:
    191                                         if not purgeApp.has_category('Zomando'):
    192                                                 self._debug("Removed related zomando app "+str(purgeApp.get_id()))
    193                                                 store.remove_app(purgeApp)
     178        def _purge_zomandos(self,zmd_apps,store):
     179                for zmd_id in zmd_apps:
     180                        self._debug("Searching debs related to "+zmd_id)
     181                        purge_list=store.get_apps_by_id(zmd_id)
     182                        purge_list.extend(store.get_apps_by_id(zmd_id+".desktop"))
     183                        for purge_app in purge_list:
     184                                if purge_app:
     185                                        if not purge_app.has_category('Zomando'):
     186                                                self._debug("Removed related zomando app "+str(purge_app.get_id()))
     187                                                store.remove_app(purge_app)
    194188                return(store)
    195189        #def _purge_zomandos
     
    209203                                blFile=open('/usr/share/lliurex-store/files/blacklist.json').read()
    210204                                blacklist=json.loads(blFile)
    211                                 blApps=[]
     205                                blacklist_apps=[]
    212206                                if flavour in blacklist:
    213                                         blApps=blacklist[flavour]
     207                                        blacklist_apps=blacklist[flavour]
    214208                                if "all" in blacklist:
    215                                         blApps.extend(blacklist["all"])
    216                                 blRegEx=[]
    217                                 for blApp in blApps:
    218                                         self._debug("Blacklisted app: "+blApp)
    219                                         resultRe=re.search('([^a-zA-Z0-9_-])',blApp)
    220                                         if resultRe:
    221                                                 if blApp[0]=='*':
    222                                                         blApp='.'+blApp
    223                                                 blRegEx.append("("+blApp+")")
     209                                        blacklist_apps.extend(blacklist["all"])
     210                                blacklist_re=[]
     211                                for blacklist_app in blacklist_apps:
     212                                        self._debug("Blacklisted app: "+blacklist_app)
     213                                        re_result=re.search('([^a-zA-Z0-9_-])',blacklist_app)
     214                                        if re_result:
     215                                                if blacklist_app[0]=='*':
     216                                                        blacklist_app='.'+blacklist_app
     217                                                blacklist_re.append("("+blacklist_app+")")
    224218                                        else:
    225                                                 app=store.get_app_by_pkgname(blApp)
     219                                                app=store.get_app_by_pkgname(blacklist_app)
    226220                                                if app:
    227221                                                        self._debug("Removed "+str(app))
    228222                                                        store.remove_app(app)
    229223                                                else:
    230                                                         self._debug("App "+blApp+" from blacklist not found in store. Assigned to RE blacklist")
    231                                                         blRegEx.append("("+blApp+")")
    232                                 if blRegEx:
     224                                                        self._debug("App "+blacklist_app+" from blacklist not found in store. Assigned to RE blacklist")
     225                                                        blacklist_re.append("("+blacklist_app+")")
     226                                if blacklist_re:
    233227                                        self._debug("Attempting to remove apps by RE match")
    234228                                        for app in store.get_apps():
    235                                                 for blApp in blRegEx:
    236                                                         resultRe=re.search(blApp,app.get_id())
    237                                                         if resultRe:
     229                                                for blacklist_app in blacklist_re:
     230                                                        re_result=re.search(blacklist_app,app.get_id())
     231                                                        if re_result:
    238232                                                                store.remove_app(app)
    239                                                                 self._debug("Removed "+str(app.get_id()) +" as matches with "+blApp)
     233                                                                self._debug("Removed "+str(app.get_id()) +" as matches with "+blacklist_app)
    240234                        else:
    241235                                self._debug('No blacklist to check')
     
    246240        #def _apply_blacklist
    247241
    248         def _download_bundles_catalogue(self):
    249                 CURSOR_UP='\033[F'
    250                 ERASE_LINE='\033[K'
    251                 content=''
    252                 applist=[]
    253                 progressBar="#"
    254                 repoList={'appimg':['https://dl.bintray.com/probono/AppImages']}
    255                 #For get the description of an app we must go to a specific url.
    256                 #$(appname) we'll be replaced with the appname so the url matches the right one.
    257                 #If other site has other url naming convention it'll be mandatory to define it with the appropiate replacements
    258                 infoList={'appimg':'https://bintray.com/probono/AppImages/$(appname)'}
    259                 self.descDict={}
    260 
    261                 for repoType,repoTypeList in repoList.items():
    262                         infoPage=infoList[repoType]
    263                         outdir=self.bundleDir+'/'+repoType+'/'
    264                         if self._chk_bundle_dir(outdir):
    265                                 for repo in repoTypeList:
    266                                         self._debug(("Fetching repo %s")%(repo))
    267 #                                       print (("Fetching %s catalogue: "+progressBar)%repoType,end="\r")
    268 #                                       progressBar=progressBar+"#"
    269 #                                       print (("Fetching %s catalogue: "+progressBar)%repoType,end="\r")
    270                                         applist=self._generate_applist(self._fetch_repo(repo))
    271 #                                       progressBar=progressBar+"##"
    272 #                                       print (("Fetching %s catalogue: "+progressBar)%repoType,end="\r")
    273                                         self._debug("Processing info...")
    274                                         self._th_generate_xml_catalog(applist,outdir,infoPage,repoType,progressBar)
    275                                         self._debug("Fetched repo "+repo)
    276 #                                       print (("Removing old entries..."))
    277                                         self._clean_bundle_catalogue(applist,outdir)
    278                         else:
    279                                 print("permission denied")
    280                 return(True)
    281 
    282         def _chk_bundle_dir(self,outdir):
    283                 msg_status=True
    284                 if not os.path.isdir(outdir):
    285                         try:
    286                                 os.makedirs(outdir)
    287                         except:
    288                                 msg_status=False
    289                 return(os.access(outdir,os.W_OK|os.R_OK|os.X_OK|os.F_OK))
    290 
    291         def _fetch_repo(self,repo):
    292                 with urllib.request.urlopen(repo) as f:
    293                         content=(f.read().decode('utf-8'))
    294                 return(content)
    295 
    296         def _generate_applist(self,content):
    297                 garbageList=[]
    298                 applist=[]
    299                 garbageList=content.split(' ')
    300                 for garbageLine in garbageList:
    301                         if garbageLine.endswith('AppImage"'):
    302                                 app=garbageLine.replace('href=":','')
    303                                 applist.append(app.replace('"',''))
    304                 return(applist)
    305 
    306         def _th_generate_xml_catalog(self,applist,outdir,infoPage,repoType,progressBar=''):
    307                 CURSOR_UP='\033[F'
    308                 ERASE_LINE='\033[K'
    309                 oldName=''
    310                 oldDesc=''
    311                 maxconnections = 10
    312                 semaphore = threading.BoundedSemaphore(value=maxconnections)
    313                 randomList = list(applist)
    314                 random.shuffle(randomList)
    315                 lenAppList=len(randomList)
    316                 inc=30/lenAppList
    317 #               print (CURSOR_UP)
    318                 for app in randomList:
    319                         th=threading.Thread(target=self._th_write_xml, args = (app,outdir,infoPage,semaphore,inc))
    320                         th.start()
    321                 os.system('setterm -cursor off')
    322                 while threading.active_count()>2: #Discard both main and own threads
    323                         for i in range(len(progressBar),int(self.progress)):
    324                                 progressBar='#'+progressBar
    325 #                       print (CURSOR_UP)
    326 #                       print (("Fetching %s catalogue: "+progressBar)%repoType,end="\r")
    327                 os.system('setterm -cursor on')
    328                 print('')
    329 
    330         def _th_write_xml(self,app,outdir,infoPage,semaphore,inc):
    331                 semaphore.acquire()
    332                 lock=threading.Lock()
    333                 nameSplitted=app.split('-')
    334                 name=nameSplitted[0]
    335                 version=nameSplitted[1]
    336                 arch=nameSplitted[2]
    337                 filename=outdir+app.lower().replace('appimage',"appdata.xml")
    338                 self._debug("checking if we need to download "+filename)
    339                 if not os.path.isfile(filename):
    340                         self._debug("Generating "+app+" xml")
    341                         f=open(filename,'w')
    342                         f.write('<?xml version="1.0" encoding="UTF-8"?>'+"\n")
    343                         f.write("<components version=\"0.10\">\n")
    344                         f.write("<component  type=\"desktop-application\">\n")
    345                         f.write("  <id>"+app.lower()+"</id>\n")
    346                         f.write("  <pkgname>"+app+"</pkgname>\n")
    347                         f.write("  <name>"+name+"</name>\n")
    348                         f.write("  <metadata_license>CC0-1.0</metadata_license>\n")
    349                         f.write("  <provides><binary>"+app+"</binary></provides>\n")
    350                         f.write("  <releases>\n")
    351                         f.write("  <release version=\""+version+"\" timestamp=\"1408573857\"></release>\n")
    352                         f.write("  </releases>\n")
    353                         f.write("  <launchable type=\"desktop-id\">"+name+".desktop</launchable>\n")
    354                         with lock:
    355                                 if name in self.descDict.keys():
    356                                         description=self.descDict[name]
    357                                 else:
    358                                         description=self._get_description(name,infoPage)
    359                                         self.descDict.update({name:description})
    360                         summary=' '.join(list(description.split(' ')[:8]))
    361                         description="This is an AppImage bundle of app "+name+". It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully."
    362                         if not summary:
    363                                 summary=' '.join(list(description.split(' ')[:8]))
    364                         f.write("  <description><p></p><p>"+description+"</p></description>\n")
    365                         f.write("  <summary>"+summary+"...</summary>\n")
    366                         f.write("  <bundle type=\"appimage\">"+app+"</bundle>\n")
    367                         f.write("  <keywords>\n")
    368                         f.write("       <keyword>"+name+"</keyword>\n")
    369                         f.write("       <keyword>appimage</keyword>\n")
    370                         f.write("  </keywords>\n")
    371                         f.write("  <categories>\n")
    372                         f.write("       <category>AppImage</category>\n")
    373                         f.write("       <category>GTK</category>\n")
    374                         f.write("  </categories>\n")
    375                         f.write("<icon type=\"cached\">"+name+"_"+name+".png</icon>\n")
    376                         f.write("</component>\n")
    377                         f.write("</components>\n")
    378                         f.close()
    379                 with lock:
    380                         self.progress=self.progress+inc
    381                 semaphore.release()
    382        
    383         def _get_description(self,appName,infoPage):
    384                 desc=''
    385                 if '$(appname)' in infoPage:
    386                         infoPage=infoPage.replace('$(appname)',appName)
    387                 self._debug("Getting description from "+infoPage)
    388                 try:
    389                         with urllib.request.urlopen(infoPage) as f:
    390                                 content=(f.read().decode('utf-8'))
    391                                 soup=BeautifulSoup(content,"html.parser")
    392                                 descDiv=soup.findAll('div', attrs={ "class" : "description-text"})
    393                         if len(descDiv)>0:
    394                                 desc=descDiv[0].text
    395                                 desc=desc.replace(':','.')
    396                                 desc=desc.replace('&','&amp;')
    397                 except Exception as e:
    398                         print("Can't get description from "+infoPage)
    399                         print(str(e))
    400                         pass
    401                 return(desc)
    402 
    403         def _clean_bundle_catalogue(self,applist,outdir):
    404                 xmlList=[]
    405                 applist=[item.lower() for item in applist]
    406                 for xmlFile in os.listdir(outdir):
    407                         if xmlFile.endswith('appdata.xml'):
    408                                 xmlList.append(xmlFile.lower().replace('appdata.xml','appimage'))
    409        
    410                 if xmlList:
    411                         discardList=list(set(xmlList).difference(applist))
    412                         for discardFile in discardList:
    413                                 os.remove(outdir+'/'+discardFile.replace('appimage','appdata.xml'))
    414         #def _clean_appImg_repo
    415 
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/searchManager.py

    r6547 r6645  
    77        def __init__(self):
    88                self.locale=locale.getlocale()[0]
    9                 self.dbg=0
     9                self.dbg=False
    1010                self.store=''
    11                 self.pluginInfo={'search':'*','list':'*','list_sections':'*','info':'*'}
    12                 self.precision=10
     11                self.plugin_actions={'search':'*','list':'*','list_sections':'*','info':'*'}
     12                self.precision=1
    1313                self.applist=[]
    1414                self.progress=0
     
    2121                return (self.applist)
    2222
    23         def set_debug(self,dbg='1'):
    24                 self.dbg=int(dbg)
     23        def set_debug(self,dbg):
     24                self.dbg=dbg
    2525                self._debug ("Debug enabled")
    2626        #def set__debug
    2727
    2828        def _debug(self,msg=''):
    29                 if self.dbg==1:
     29                if self.dbg:
    3030                        print ('DEBUG Search: '+msg)
    3131        #def _debug
    3232
    3333        def register(self):
    34                 return(self.pluginInfo)
    35 
    36         def execute_action(self,appstreamStore,action,tokens,exact_match_for_search=False):
     34                return(self.plugin_actions)
     35
     36        def execute_action(self,appstreamStore,action,tokens,exact_match_for_search=False,max_results=0):
    3737                self.progress=0
    3838                if not type(tokens) is str:
     
    5757                if self.store:
    5858                        if action=='list':
    59                                 self._list_category(tokens)
     59                                self._list_category(tokens,max_results)
    6060                        if action=='list_sections':
    6161                                self._list_sections()
     
    9696        def _list_sections(self):
    9797                applist=[]
    98                 catDict={}
     98                categories={}
    9999                for app in self.store.get_apps():
    100100                        for cat in app.get_categories():
    101                                 if cat not in catDict.keys():
    102                                         catDict[cat]=1
     101                                if cat not in categories.keys():
     102                                        categories[cat]=1
    103103                                else:
    104                                         catDict[cat]=catDict[cat]+1
    105                 for section in catDict:
    106                         applist.append({str(section):catDict[section]})
     104                                        categories[cat]=categories[cat]+1
     105                for section in categories:
     106                        applist.append({str(section):categories[section]})
    107107                self.result['data']=applist
    108108                if len(applist):
     
    112112                return(applist)
    113113
    114         def _list_category(self,tokens=[]):
     114        def _list_category(self,tokens=[],max_results=0):
    115115                applist=[]
    116116                self._debug("tokens: "+str(tokens))
     117                self._debug("Max results: %s"%max_results)
    117118                if len(tokens)>=1:
    118119                        self._debug("Searching category "+str(tokens))
    119                         setCategories=set(tokens)
     120                        categories_set=set(tokens)
    120121                        apps_in_store=self.store.get_apps()
    121122                        count_apps=len(apps_in_store)
     
    124125                        for app in apps_in_store:
    125126                                self.progress=self.progress+inc
    126                                 if 'setCategories' in locals():
     127                                if 'categories_set' in locals():
    127128                                        try:
    128                                                 appCategories=[cat.lower() for cat in app.get_categories()]
     129                                                app_categories=[cat.lower() for cat in app.get_categories()]
    129130                                        except:
    130131                                                pass
    131                                         setAppCategories=set(appCategories)
    132                                         if setCategories.issubset(setAppCategories):
     132                                        app_categories_set=set(app_categories)
     133                                        if categories_set.issubset(app_categories_set):
    133134                                                self._debug("Found "+app.get_id())
    134135                                                applist.append(app)
     
    136137                        self._debug("Loading all apps in store")
    137138                        applist=self.store.get_apps()
     139                        categories_set=set(['snap','appimage'])
     140                        applist_2=[]
     141                        for app in applist:
     142                                if 'categories_set' in locals():
     143                                        try:
     144                                                app_categories=[cat.lower() for cat in app.get_categories()]
     145                                        except:
     146                                                pass
     147                                        app_categories_set=set(app_categories)
     148                                        if not categories_set.issubset(app_categories_set):
     149                                                applist_2.append(app)
     150                                        else:
     151                                                print("*************")
     152                                                print("Removing %s"%app.get_pkgname())
     153                                                print("*************")
     154                        applist=applist_2
    138155#                       for app in applist:
    139156#                               self._debug("Added "+app.get_id())
     157                if max_results:
     158                        applist=applist[0:max_results]
     159                #List only valid categories
     160
    140161                self.result['data']=applist
    141162                if len(applist):
     
    145166                return(applist)
    146167
    147         def _app_exists(self,appName):
    148                 self._debug("Trying direct match for "+appName)
     168        def _app_exists(self,app_name):
     169                self._debug("Trying direct match for "+app_name)
    149170                app=None
    150171                #1.- Try exact match
    151                 app=self.store.get_app_by_id(appName)
     172                app=self.store.get_app_by_id(app_name)
    152173                if not app:
    153174                #2.- Try exact match with zero-lliurex- for the zomandos
    154                         app=self.store.get_app_by_id("zero-lliurex-"+appName)
    155                         if not app:
    156                 #2.- Try exact match with .desktop
    157                                 app=self.store.get_app_by_id(appName+".desktop")
     175                        app=self.store.get_app_by_id("zero-lliurex-"+app_name)
     176                if not app:
     177                #3.- Try exact match with .desktop
     178                        app=self.store.get_app_by_id(app_name+".desktop")
     179                if not app:
     180                #4.- Try exact match by pkgname
     181                        app=self.store.get_app_by_pkgname(app_name)
     182                self._debug("App found %s"%app)
    158183                return(app)
    159184
     
    162187                self._debug("Searching app by fuzzy match")
    163188                if not applist:
    164                         insertPosition=1
    165                 else:
    166                         insertPosition=len(applist)+1
     189                        position=1
     190                else:
     191                        position=len(applist)+1
    167192                apps_in_store=self.store.get_apps()
    168193                if apps_in_store:
    169                         auxDict={}
     194                        tmp_app_dict={}
    170195                        count_apps=len(apps_in_store)
    171196                        self.progress=0
     
    179204                                                        if "appimage" in app.get_id().lower():
    180205                                                                score=1
    181                                                         if score in auxDict:
    182                                                                 auxDict[score].append(app)
     206                                                        if score in tmp_app_dict:
     207                                                                tmp_app_dict[score].append(app)
    183208                                                        else:
    184                                                                 auxDict[score]=[app]
    185                         for match in sorted(auxDict):
    186                                 for app in auxDict[match]:
     209                                                                tmp_app_dict[score]=[app]
     210                        for match in sorted(tmp_app_dict):
     211                                for app in tmp_app_dict[match]:
    187212                                        if app not in applist:
    188213                                                self._debug("Adding app "+app.get_id() + " with score: "+str(match))
     
    192217        def _get_app_by_pkgname(self,tokens,applist=[]):
    193218                if not applist:
    194                         insertPosition=1
    195                 else:
    196                         insertPosition=len(applist)+1
     219                        position=1
     220                else:
     221                        position=len(applist)+1
    197222                apps_in_store=self.store.get_apps()
    198223                if apps_in_store:
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/shManager.py

    r4811 r6645  
    1212        def __init__(self):
    1313                self.locale=locale.getlocale()[0]
    14                 self.dbg=0
    15                 self.pluginInfo={'install':'sh','pkginfo':'sh'}
     14                self.dbg=False
     15                self.plugin_actions={'install':'sh','pkginfo':'sh'}
    1616                self.progress=0
    1717                self.result={}
     
    2121        #def __init__
    2222
    23         def set_debug(self,dbg='1'):
    24                 self.dbg=int(dbg)
     23        def set_debug(self,dbg):
     24                self.dbg=dbg
    2525                self._debug ("Debug enabled")
    2626        #def set_debug
    2727
    2828        def _debug(self,msg=''):
    29                 if self.dbg==1:
     29                if self.dbg:
    3030                        print ('DEBUG Sh: '+msg)
    3131        #def debug
    3232
    3333        def register(self):
    34                 return(self.pluginInfo)
     34                return(self.plugin_actions)
    3535        #def register
    3636
     
    4040                count=len(applist)
    4141                if (action):
    42                         for appInfo in applist:
    43                                 self._debug("Executing action "+action+" for "+str(appInfo))
     42                        for app_info in applist:
     43                                self._debug("Executing action "+action+" for "+str(app_info))
    4444                                if action=='install':
    45                                         self.result['data'].append(self._install_App(appInfo))
     45                                        self.result['data'].append(self._install_App(app_info))
    4646                                if action=='pkginfo':
    47                                         self.result['data'].append(self._get_Sh_Info(appInfo))
     47                                        self.result['data'].append(self._get_Sh_Info(app_info))
    4848                self.progress=100
    4949                return(self.result)
     
    5353                self.result['status']={'status':status,'msg':msg}
    5454
    55         def _callback(self,partialSize=0,totalSize=0):
     55        def _callback(self,partial_size=0,total_size=0):
    5656                limit=99
    57                 if partialSize!=0 and totalSize!=0:
    58                         inc=round(partialSize/totalSize,2)*100
     57                if partial_size!=0 and total_size!=0:
     58                        inc=round(partial_size/total_size,2)*100
    5959                        self.progress=inc
    6060                else:
     
    6767        #def _callback
    6868
    69         def _install_App(self,appInfo):
     69        def _install_App(self,app_info):
    7070                return_msg=False
    71                 appUrl=appInfo['installerUrl']
    72                 self._debug("Checking availabilty for "+appUrl)
    73                 tmpDir=tempfile.mkdtemp(None,None,'/tmp')
    74                 fileName=appUrl.split('/')[-1]
    75                 dest_path=tmpDir+'/'+fileName
    76                 if self._download_App(appUrl,dest_path):
    77                         os.chdir(tmpDir)
     71                app_url=app_info['installerUrl']
     72                self._debug("Checking availabilty for "+app_url)
     73                tmp_dir=tempfile.mkdtemp(None,None,'/tmp')
     74                file_name=app_url.split('/')[-1]
     75                dest_path=tmp_dir+'/'+file_name
     76                if self._download_App(app_url,dest_path):
     77                        os.chdir(tmp_dir)
    7878                        os.chmod(dest_path, stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR)
    7979                        err=0
    8080                        try:
    81                                 cmdsudo=['gksudo',dest_path]
    82                                 self._debug("executing "+str(cmdsudo))
    83                                 cmdCmd=subprocess.Popen(cmdsudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
    84 #                               cmdCmd=subprocess.check_output(cmdsudo)
    85                                 cmdLauncher=os.path.basename(dest_path)
    86                                 cmdLauncher=os.path.splitext(cmdLauncher)[0]
    87                                 while cmdCmd.poll() is None:
     81                                sudo_cmd=['gksudo',dest_path]
     82                                self._debug("executing "+str(sudo_cmd))
     83                                launched_cmd=subprocess.Popen(sudo_cmd,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
     84#                               launched_cmd=subprocess.check_output(sudo_cmd)
     85                                cmd_launcher=os.path.basename(dest_path)
     86                                cmd_launcher=os.path.splitext(cmd_launcher)[0]
     87                                while launched_cmd.poll() is None:
    8888                                        self._callback()
    8989                                        time.sleep(0.4)
    90                                 if cmdCmd.poll():
    91                                         if cmdCmd.poll()==255:
     90                                if launched_cmd.poll():
     91                                        if launched_cmd.poll()==255:
    9292                                                err=303
    9393                                        else:
    94                                                 err=cmdCmd.poll()
     94                                                err=launched_cmd.poll()
    9595                                                err=3 #Force "package not installed" error
    96                                 cmdResult=cmdCmd.stdout.read()
    97                                 cmdError=cmdCmd.stderr.read()
    98                                 self._debug("Error: "+str(cmdError))
    99                                 self._debug("Result: "+str(cmdResult))
     96                                cmd_status=launched_cmd.stdout.read()
     97                                cmd_err=launched_cmd.stderr.read()
     98                                self._debug("Error: "+str(cmd_err))
     99                                self._debug("Result: "+str(cmd_status))
    100100                        except subprocess.CalledProcessError as callError:
    101101#                               err=callError.returncode
     
    108108                        err=11
    109109                self._set_status(err)
    110                 return appInfo
     110                return app_info
    111111        #def install_App
    112112
    113         def _download_App(self,appUrl,dest_path=None):
    114                 appUrl.strip()
     113        def _download_App(self,app_url,dest_path=None):
     114                app_url.strip()
    115115                if not dest_path:
    116                         tmpDir=tempfile.mkdtemp(None,None,'/tmp')
    117                         dest_path=tmpDir+'/'+appUrl.split('/')[-1]
    118                 self._debug("Downloading "+appUrl+" to "+dest_path)     
     116                        tmp_dir=tempfile.mkdtemp(None,None,'/tmp')
     117                        dest_path=tmp_dir+'/'+app_url.split('/')[-1]
     118                self._debug("Downloading "+app_url+" to "+dest_path)   
    119119                try:
    120 #                       urllib.request.urlretrieve(appUrl,dest_path)
    121                         with urllib.request.urlopen(appUrl) as response, open(dest_path, 'wb') as out_file:
     120#                       urllib.request.urlretrieve(app_url,dest_path)
     121                        with urllib.request.urlopen(app_url) as response, open(dest_path, 'wb') as out_file:
    122122                                bf=16*1024
    123123                                acumbf=0
    124                                 shSize=int(response.info()['Content-Length'])
     124                                sh_size=int(response.info()['Content-Length'])
    125125                                while True:
    126                                         if acumbf>=shSize:
     126                                        if acumbf>=sh_size:
    127127                                                break
    128128                                        shutil.copyfileobj(response, out_file,bf)
    129129                                        acumbf=acumbf+bf
    130                                         self._callback(acumbf,shSize)
     130                                        self._callback(acumbf,sh_size)
    131131                        return_msg=True
    132132                except Exception as e:
     
    136136        #def _download_App
    137137
    138         def _get_Sh_Info(self,appInfo):
    139                 appUrl=appInfo['installerUrl']
    140                 self._debug("Connecting to "+appUrl)
    141                 appUrl.strip()
     138        def _get_Sh_Info(self,app_info):
     139                app_url=app_info['installerUrl']
     140                self._debug("Connecting to "+app_url)
     141                app_url.strip()
    142142                try:
    143                         info=urllib.request.urlopen(appUrl)
    144                         appInfo['size']=info.info()['Content-Length']
     143                        info=urllib.request.urlopen(app_url)
     144                        app_info['size']=info.info()['Content-Length']
    145145                        err=0
    146146                except:
    147147                        err=11
    148148                self._set_status(err)
    149                 return(appInfo)
     149                return(app_info)
    150150
    151151        #def _get_info
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/zmdManager.py

    r6057 r6645  
    1515        def __init__(self):
    1616                self.locale=locale.getlocale()[0]
    17                 self.dbg=0
    18                 self.zmdPath='/usr/share/zero-center/zmds'
     17                self.dbg=False
     18                self.zmd_folder='/usr/share/zero-center/zmds'
    1919                self.disabled=False
    20                 if hasattr(sys,'last_value') or not (os.path.exists(self.zmdPath)):
     20                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
    2222                        self.disabled=True
    23                 self.pluginInfo={'install':'zmd','pkginfo':'zmd','remove':'zmd'}
     23                self.plugin_actions={'install':'zmd','pkginfo':'zmd','remove':'zmd'}
    2424                self.progress=0
    2525                self.n4dclient=''
     
    3030        #def __init__
    3131
    32         def set_debug(self,dbg='1'):
    33                 self.dbg=int(dbg)
     32        def set_debug(self,dbg=True):
     33                self.dbg=dbg
    3434                self._debug ("Debug enabled")
    3535        #def set__debug
    3636
    3737        def _debug(self,msg=''):
    38                 if self.dbg==1:
     38                if self.dbg:
    3939                        print ('DEBUG Zmd: '+str(msg))
    4040        #def _debug
    4141
    4242        def register(self):
    43                 return(self.pluginInfo)
     43                return(self.plugin_actions)
    4444        #def register
    4545
     
    5555                        try:
    5656                                self.n4dclient=self._n4d_connect()
    57                                 for appInfo in applist:
     57                                for app_info in applist:
    5858                                        if (action):
    5959                                                if action=='install':
    60                                                         dataList.append(self._install_Zmd(appInfo))
     60                                                        dataList.append(self._install_Zmd(app_info))
    6161                                                if action=='remove':
    62                                                         dataList.append(self._remove_Zmd(appInfo))
     62                                                        dataList.append(self._remove_Zmd(app_info))
    6363                                                if action=='pkginfo':
    64                                                         dataList.append(self._get_Zmd_Info(appInfo))
     64                                                        dataList.append(self._get_Zmd_Info(app_info))
    6565                                self.result['data']=list(dataList)
    6666                        except:
     
    7575#               dataList['status']={'status':status,'msg':msg}
    7676       
    77         def _callback(self,zmdLauncher):
     77        def _callback(self,zmd_launcher):
    7878                inc=1
    7979                limit=99
    8080                n4dvars=self.n4dclient.get_variable("","VariablesManager","ZEROCENTER")
    81                 if zmdLauncher in n4dvars.keys():
    82                         if n4dvars[zmdLauncher]['pulsating']:
     81                if zmd_launcher in n4dvars.keys():
     82                        if n4dvars[zmd_launcher]['pulsating']:
    8383                                margin=limit-self.progress
    8484                                inc=round(margin/limit,3)
     
    8686        #def _callback
    8787
    88         def _install_Zmd(self,appInfo):
    89                 zmd=self.zmdPath+'/'+appInfo['package']+'.zmd'
     88        def _install_Zmd(self,app_info):
     89                zmd=self.zmd_folder+'/'+app_info['package']+'.zmd'
    9090                self._debug("Installing "+str(zmd))
    91                 appInfo=self._get_Zmd_Info(appInfo)
    92                 if appInfo['state']=='installed':
     91                app_info=self._get_Zmd_Info(app_info)
     92                if app_info['state']=='installed':
    9393                        err=4
    9494                else:
     
    9696                                err=0
    9797                                try:
    98 #                                       zmdsudo=['gksudo',zmd]
    99                                         zmdsudo=['pe',zmd]
    100                                         self._debug("executing "+str(zmdsudo))
    101                                         zmdCmd=subprocess.Popen(zmdsudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
    102                                         zmdLauncher=os.path.basename(zmd)
    103                                         zmdLauncher=os.path.splitext(zmdLauncher)[0]
    104                                         while zmdCmd.poll() is None:
    105                                                 self._callback(zmdLauncher)
     98#                                       zmd_sudo=['gksudo',zmd]
     99                                        zmd_sudo=['pe',zmd]
     100                                        self._debug("executing "+str(zmd_sudo))
     101                                        launched_zmd=subprocess.Popen(zmd_sudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
     102                                        zmd_launcher=os.path.basename(zmd)
     103                                        zmd_launcher=os.path.splitext(zmd_launcher)[0]
     104                                        while launched_zmd.poll() is None:
     105                                                self._callback(zmd_launcher)
    106106                                                time.sleep(0.4)
    107                                         zmdResult=zmdCmd.stdout.read()
    108                                         zmdError=zmdCmd.stderr.read()
    109                                         self._debug("Error: "+str(zmdError))
    110                                         self._debug("Result: "+str(zmdResult))
     107                                        zmd_status=launched_zmd.stdout.read()
     108                                        zmd_err=launched_zmd.stderr.read()
     109                                        self._debug("Error: "+str(zmd_err))
     110                                        self._debug("Result: "+str(zmd_status))
    111111                                except Exception as e:
    112112                                        self._debug(str(e))
    113113                                finally:
    114                                         appInfo=self._get_Zmd_Info(appInfo)
    115                                         if appInfo['state']!='installed':
     114                                        app_info=self._get_Zmd_Info(app_info)
     115                                        if app_info['state']!='installed':
    116116                                                err=5
    117117                        else:
    118118                                err=8
    119119                self._set_status(err)
    120                 return(appInfo)
     120                return(app_info)
    121121        #def _install_Zmd
    122122
    123         def _remove_Zmd(self,appInfo):
    124                 zmd=appInfo['package']+'.zmd'
     123        def _remove_Zmd(self,app_info):
     124                zmd=app_info['package']+'.zmd'
    125125                self._debug("Removing "+str(zmd))
    126                 os.chdir(self.zmdPath)
     126                os.chdir(self.zmd_folder)
    127127                sw_continue=False
    128128                err=0
    129129                try:
    130                         removePackages=[]
     130                        remove_packages=[]
    131131                        f=open(zmd,'r')
    132132                        for line in f:
     
    144144                                                pkg=pkg.replace('"','')
    145145                                                self._debug("Append to remove list: "+pkg)
    146                                                 removePackages.append(pkg)
     146                                                remove_packages.append(pkg)
    147147                                        f2.close()
    148148                        f.close()
     
    151151                        print(str(e))
    152152                if sw_continue:
    153                         zeroScript='/tmp/zeroScript'
    154                         f3=open(zeroScript,'w')
     153                        zmd_script='/tmp/zmd_script'
     154                        f3=open(zmd_script,'w')
    155155                        f3.write('#!/bin/bash'+"\n")
    156                         for pkg in removePackages:
     156                        for pkg in remove_packages:
    157157                                f3.write('/usr/bin/zero-installer remove '+pkg+"\n")
    158                         f3.write ("zero-center set-non-configured "+appInfo['package']+"\n")
     158                        f3.write ("zero-center set-non-configured "+app_info['package']+"\n")
    159159                        f3.close()
    160                         os.chmod(zeroScript,stat.S_IEXEC|stat.S_IREAD|stat.S_IWRITE|stat.S_IROTH|stat.S_IWOTH|stat.S_IXOTH|stat.S_IRGRP|stat.S_IWGRP|stat.S_IXGRP)
    161                         zmdsudo=['gksudo',zeroScript]
     160                        os.chmod(zmd_script,stat.S_IEXEC|stat.S_IREAD|stat.S_IWRITE|stat.S_IROTH|stat.S_IWOTH|stat.S_IXOTH|stat.S_IRGRP|stat.S_IWGRP|stat.S_IXGRP)
     161                        zmd_sudo=['gksudo',zmd_script]
    162162                        try:
    163                                 self._debug("Executing "+str(zmdsudo))
    164                                 zmdLauncher=os.path.basename(zmd)
    165                                 zmdLauncher=os.path.splitext(zmdLauncher)[0]
    166                                 zmdCmd=subprocess.Popen(zmdsudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
     163                                self._debug("Executing "+str(zmd_sudo))
     164                                zmd_launcher=os.path.basename(zmd)
     165                                zmd_launcher=os.path.splitext(zmd_launcher)[0]
     166                                launched_zmd=subprocess.Popen(zmd_sudo,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)
    167167                                self._debug("Launched")
    168                                 while zmdCmd.poll() is None:
    169                                         self._callback(zmdLauncher)
     168                                while launched_zmd.poll() is None:
     169                                        self._callback(zmd_launcher)
    170170                                        time.sleep(0.2)
    171                                 zmdResult=zmdCmd.stdout.read()
    172                                 zmdError=zmdCmd.stderr.read()
     171                                zmd_status=launched_zmd.stdout.read()
     172                                zmd_err=launched_zmd.stderr.read()
    173173                        except Exception as e:
    174174                                err=6
    175175                                self._debug(str(e))
    176                         self._debug("Error: "+str(zmdError))
    177                         self._debug("Result: "+str(zmdResult))
    178                         appInfo=self._get_Zmd_Info(appInfo)
    179                         if appInfo['state']=='installed':
     176                        self._debug("Error: "+str(zmd_err))
     177                        self._debug("Result: "+str(zmd_status))
     178                        app_info=self._get_Zmd_Info(app_info)
     179                        if app_info['state']=='installed':
    180180                                err=6
    181                         os.remove(zeroScript)
     181                        os.remove(zmd_script)
    182182                else:
    183183                        err=6
    184184                self._set_status(err)
    185                 return(appInfo)
     185                return(app_info)
    186186        #def _remove_Zmd
    187187
    188         def _get_Zmd_Info(self,appInfo):
    189                 zmd=appInfo['package']
    190                 appInfo['state']='Available'
     188        def _get_Zmd_Info(self,app_info):
     189                zmd=app_info['package']
     190                app_info['state']='Available'
    191191                try:
    192192                        n4dvars=self.n4dclient.get_variable("","VariablesManager","ZEROCENTER")
     
    197197                                                if 'state' in n4dvars[key]:
    198198                                                        if n4dvars[key]['state']==1:
    199                                                                 appInfo['state']='installed'
     199                                                                app_info['state']='installed'
    200200                        else:
    201201                                self._set_status(2)
    202202                except Exception as e:
    203203                        self._set_status(10)
    204 #               self.result['data'].append(appInfo)
    205 #               self.result.append(appInfo)
    206                 if appInfo['state']!='installed':
    207                 #There're some zomandos that may be unregistered, so we check again
    208                         zmdApp='/usr/share/zero-center/applications/'+zmd+".app"
    209                         if os.path.isfile(zmdApp):
    210                                 f=open(zmdApp,'r')
    211                                 fileContent=f.readlines()
    212                                 f.close
    213                                 sw_service=False
    214                                 for line in fileContent:
    215                                         if line.startswith('Service'):
    216                                                 sw_service=True
    217                                                 if 'True' not in line:
    218                                                         print(line)
    219                                                         appInfo['state']='installed'
    220                                 if sw_service==False:
    221                                         appInfo['state']='installed'
    222                        
    223                 return(appInfo)
     204#               self.result['data'].append(app_info)
     205#               self.result.append(app_info)
     206                return(app_info)
    224207        #def _get_Zmd_Info
    225208       
  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py

    r6547 r6645  
    1515#####
    1616
    17 class StoreManager:
    18         def __init__(self,args=()):
    19                 self.dbg=0
    20                 self._propagate_dbg=0
     17class StoreManager():
     18#       def __init__(self,snap=False,appimage=False,dbg=False):
     19        def __init__(self,**kwargs):
     20                self.dbg=False
     21                if 'dbg' in kwargs.keys():
     22                        self.dbg=kwargs['dbg']
     23                self._propagate_dbg=False
    2124                self.store=None
    22                 self.relatedActions={
     25                self.related_actions={
    2326                                        'load':['load'],
    2427                                        'search':['search','get_info','pkginfo'],
     
    2932                                        'remove':['search','get_info','pkginfo','remove']
    3033                                        }
    31                 self.loadBundles=False
    32                 if args:
    33                         if args[0]==1:
    34                                 self.loadBundles=True
    35                         if args[1]==1:
    36                                 self.dbg=args
     34                self.cli_mode=[]                        #List that controls cli_mode for plugins
    3735                self.threads={}                         #Dict that stores the functions that must execute each action
    38                 self.threadsProgress={}                 #"" "" "" the progress for each launched thread
    39                 self.threadsRunning={}                  #"" "" "" the running threads
    40                 self.registeredPlugins={}               #Dict that have the relation between plugins and actions
    41                 self.registerProcessProgress={}         #Dict that stores the progress for each function/parentAction pair
    42                 self.progressActions={}                 #Progress of global actions based on average progress of individual processes
    43                 self.extraActions={}            #Dict that have the actions managed by plugins and no defined on the main class as relatedActions
     36                self.threads_progress={}                        #"" "" "" the progress for each launched thread
     37                self.running_threads={}                 #"" "" "" the running threads
     38                self.plugins_registered={}              #Dict that have the relation between plugins and actions
     39                self.register_action_progress={}                #Dict that stores the progress for each function/parent_action pair
     40                self.action_progress={}                 #Progress of global actions based on average progress of individual processes
     41                self.extra_actions={}           #Dict that have the actions managed by plugins and no defined on the main class as related_actions
    4442                self.result={}                          #Result of the actions
    4543                self.lock=threading.Lock()              #locker for functions related to threads (get_progress, is_action_running...)
    46                 self.main()
     44                self.main(kwargs)
    4745        #def __init__
    4846
    49         def main(self):
     47        def main(self,args={}):
    5048                self._define_functions_for_threads()    #Function that loads the dictionary self.threads
    51                 self.__init_plugins__()                 #Function that loads the plugins
    52                 self._debug("Load bundles %s"%self.loadBundles)
    53                 if self.loadBundles:
    54                         self.execute_action('load_bundles')             #Initial load of the store
    55                 else:
    56                         self.execute_action('load')             #Initial load of the store
     49                self.__init_plugins__(args)                     #Function that loads the plugins
     50                self.execute_action('load')             #Initial load of the store
    5751        #def main
    5852
     
    6054        #Load and register the plugins from plugin dir
    6155        ####
    62         def __init_plugins__(self):
     56        def __init_plugins__(self,args={}):
    6357                package=plugins
    6458                for importer, mod, ispkg in pkgutil.walk_packages(path=package.__path__, prefix=package.__name__+'.',onerror=lambda x: None):
    65                         strImport='from '+mod+' import *'
     59                        import_mod='from '+mod+' import *'
    6660                        try:
    6761                                self._debug("Importing "+str(mod))
    68                                 exec (strImport)
     62                                exec (import_mod)
    6963                        except Exception as e:
    7064                                print(str(e))
     
    7266                for mod in (sys.modules.keys()):
    7367                        if 'plugins.' in mod:
    74                                 definedActions={}
    75                                 pluginNameUp=mod.split('.')[-1]
    76                                 pluginName=pluginNameUp.lower()
    77                                 self._debug("Initializing "+str(pluginName))
     68                                class_actions={}
     69                                plugin_name_up=mod.split('.')[-1]
     70                                plugin_name=plugin_name_up.lower()
     71                                self._debug("Initializing "+str(plugin_name))
     72                                sw_cli_mode=False
    7873                                try:
    79                                         loadedClass=eval(pluginName)()
    80                                         definedActions=loadedClass.register()
     74                                        target_class=eval(plugin_name)()
     75                                        class_actions=target_class.register()
     76                                        if 'disabled' in target_class.__dict__.keys():
     77                                                if target_class.disabled==True:
     78                                                        self._debug("Disabling plugin %s"%plugin_name)
     79                                                        continue
     80                                                #Time to check if plugin is disabled or enabled by parm
     81                                                #Values for the plugins_registered dict must be the same as the parm name that enables the plugin
     82                                                for key,value in class_actions.items():
     83                                                        val=value
     84                                                        break
     85                                                if val in args.keys():
     86                                                        if args[val]==True:
     87                                                                if target_class.disabled:
     88                                                                        self._debug("Disabling plugin %s"%plugin_name)
     89                                                                        continue
     90                                                        else:
     91                                                                self._debug("Disabling plugin %s"%plugin_name)
     92                                                                continue
     93                                                else:
     94                                                        self._debug("Disabling plugin %s"%plugin_name)
     95                                                        continue
     96                                        if 'cli_mode' in target_class.__dict__.keys():
     97                                                if 'cli' in args.keys():
     98                                                        sw_cli_mode=True
     99                                                        self._debug("Enabling cli mode for %s"%plugin_name)
    81100                                except Exception as e:
    82                                         print ("Can't initialize "+str(mod)+' '+str(loadedClass))
     101                                        print ("Can't initialize "+str(mod)+' '+str(target_class))
    83102                                        print ("Reason: "+str(e))
    84103                                        pass
    85104                       
    86                                 for action in definedActions.keys():
    87                                         if action not in self.registeredPlugins:
    88                                                 self.registeredPlugins[action]={}
    89                                         self.registeredPlugins[action].update({definedActions[action]:'plugins.'+pluginNameUp+'.'+pluginName})
    90                 self._debug(str(self.registeredPlugins))
     105                                for action in class_actions.keys():
     106                                        if action not in self.plugins_registered:
     107                                                self.plugins_registered[action]={}
     108                                        full_module_name='plugins.'+plugin_name_up+'.'+plugin_name
     109                                        self.plugins_registered[action].update({class_actions[action]:full_module_name})
     110                                        if sw_cli_mode:
     111                                                self.cli_mode.append(full_module_name)
     112
     113                self._debug(str(self.plugins_registered))
    91114        #def __init_plugins__
    92115
    93         def set_debug(self,dbg='1'):
    94                 self.dbg=int(dbg)
     116        def set_debug(self,dbg=True):
     117                self.dbg=dbg
    95118                self._debug ("Debug enabled")
    96119        #def set_debug
     
    111134        def _define_functions_for_threads(self):
    112135                self.threads['load']="threading.Thread(target=self._load_Store)"
    113                 self.threads['load_bundles']="threading.Thread(target=self._load_Store)"
     136#               self.threads['load_bundles']="threading.Thread(target=self._load_Store)"
    114137                self.threads['get_info']="threading.Thread(target=self._get_App_Info,args=[args])"
    115138                self.threads['pkginfo']="threading.Thread(target=self._get_Extended_App_Info,args=[args])"
     
    132155                if self.is_action_running('load'):
    133156                        self._join_action('load')
    134                 if self.is_action_running('load_bundles'):
    135                         self._join_action('load_bundles')
    136                 sw_withoutStatus=False
     157                        self._debug("Resumed action %s"%action)
     158                sw_track_status=False
    137159                if action not in self.threads.keys():
    138160                        #Attempt to add a new action managed by a plugin
    139161                        self._debug("Attempting to find a plugin for action "+action)
    140                         if action in self.registeredPlugins.keys():
    141                                 for packageType,plugin in self.registeredPlugins[action].items():
    142                                         self.progressActions[action]=0
    143                                         self.threads[action]='threading.Thread(target=self._execute_class_method(action,packageType,action).execute_action,args=[action])'
     162                        if action in self.plugins_registered.keys():
     163                                for package_type,plugin in self.plugins_registered[action].items():
     164                                        self.action_progress[action]=0
     165                                        self.threads[action]='threading.Thread(target=self._execute_class_method(action,package_type,action).execute_action,args=[action])'
    144166                                        break
    145                                 self._debug('Plugin for '+action+' found: '+str(self.registeredPlugins[action]))
    146                                 self.relatedActions.update({action:[action]})
    147                                 sw_withoutStatus=True
     167                                self._debug('Plugin for '+action+' found: '+str(self.plugins_registered[action]))
     168                                self.related_actions.update({action:[action]})
     169                                sw_track_status=True
    148170                if action in self.threads.keys():
    149171                        if self.is_action_running(action):
    150172                                #join thread if we're performing the same action
    151173                                self._debug("Waiting for current action "+action+" to end")
    152                                 self.threadsRunning[action].join()
     174                                self.running_threads[action].join()
    153175                        try:
    154                                 if action in self.progressActions.keys():
    155                                         self.progressActions[action]=0
    156                                 self.progressActions[action]=0
     176                                if action in self.action_progress.keys():
     177                                        self.action_progress[action]=0
     178                                self.action_progress[action]=0
    157179                                self.result[action]={}
    158                                 self.threadsRunning[action]=eval(self.threads[action])
    159                                 self.threadsRunning[action].start()
    160                                 if sw_withoutStatus:
     180                                self.running_threads[action]=eval(self.threads[action])
     181                                self.running_threads[action].start()
     182                                if sw_track_status:
    161183                                        self.result[action]['status']={'status':0,'msg':''}
    162184                                else:
    163185                                        self.result[action]['status']={'status':-1,'msg':''}
    164                                 self._debug("Thread "+str(self.threadsRunning[action])+" for action "+action+" launched")
     186                                self._debug("Thread "+str(self.running_threads[action])+" for action "+action+" launched")
    165187
    166188                        except Exception as e:
     
    182204        ####
    183205        def _execute_class_method(self,action,parms=None,launchedby=None):
    184                 exeFunction=None
     206                exe_function=None
    185207                if not parms:
    186208                        parms="*"
    187                 if action in self.registeredPlugins:
    188                         self._debug("Plugin for "+action+": "+self.registeredPlugins[action][parms])
    189                         exeFunction=eval(self.registeredPlugins[action][parms]+"()")
     209                if action in self.plugins_registered:
     210                        self._debug("Plugin for "+action+": "+self.plugins_registered[action][parms])
     211                        exe_function=eval(self.plugins_registered[action][parms]+"()")
    190212                        if self._propagate_dbg:
    191                                 exeFunction.set_debug(1)
    192                         self._registerProcessProgress(action,exeFunction,launchedby)
     213                                exe_function.set_debug()
     214                        if self.plugins_registered[action][parms] in self.cli_mode:
     215                                exe_function.cli_mode=True
     216                        self._register_action_progress(action,exe_function,launchedby)
    193217                else:
    194218                        self._debug("No plugin for action: "+action)
    195219
    196                 return (exeFunction)
     220                return (exe_function)
    197221        #def _execute_class_method
    198222
     
    204228        #  - status true/false
    205229        ###
    206         def is_action_running(self,actionSearched=None):
     230        def is_action_running(self,searched_action=None):
    207231                status=False
    208                 actionList=[]
    209                 if actionSearched:
    210                         actionList.append(actionSearched)
    211                 else:
    212                         actionList=self.relatedActions.keys()
    213 
    214                 for action in actionList:
    215                         if action in self.threadsRunning.keys():
    216                                 if self.threadsRunning[action].is_alive():
     232                action_list=[]
     233                if searched_action:
     234                        action_list.append(searched_action)
     235                else:
     236                        action_list=self.related_actions.keys()
     237
     238                for action in action_list:
     239                        if action in self.running_threads.keys():
     240                                if self.running_threads[action].is_alive():
    217241                                        status=True
    218242                                        break
    219243                                else:
    220                                         if action in self.relatedActions.keys():
    221                                                 for relatedAction in self.relatedActions[action]:
    222                                                         if relatedAction in self.threadsRunning.keys():
    223                                                                 if self.threadsRunning[relatedAction].is_alive():
     244                                        if action in self.related_actions.keys():
     245                                                for related_action in self.related_actions[action]:
     246                                                        if related_action in self.running_threads.keys():
     247                                                                if self.running_threads[related_action].is_alive():
    224248                                                                        status=True
    225249                                                                        break
     
    235259                self._debug("Joining action: "+action)
    236260                try:
    237                         self.threadsRunning[action].join()
     261                        self.running_threads[action].join()
    238262                except Exception as e:
    239263                        self._debug("Unable to join thread for: "+action)
    240264                        self._debug("Reason: "+ str(e))
    241265                finally:               
    242                         if action in self.threadsRunning.keys():
    243                                 del(self.threadsRunning[action])
     266                        if action in self.running_threads.keys():
     267                                del(self.running_threads[action])
    244268        #def _join_action
    245269
    246270        ####
    247         #Register the method and action/parentAction pair in the progress dict
     271        #Register the method and action/parent_action pair in the progress dict
    248272        #Input:
    249273        #  - action launched
    250274        #  - function (a reference to the function)
    251         #  - parentAction that owns the action (if any)
    252         ####
    253         def _registerProcessProgress(self,action,function,parentAction=None):
    254                 if action in self.registerProcessProgress.keys():
     275        #  - parent_action that owns the action (if any)
     276        ####
     277        def _register_action_progress(self,action,function,parent_action=None):
     278                if action in self.register_action_progress.keys():
    255279                        self._debug("Appended process for action: "+action +" and function: "+str(function))
    256                         self.registerProcessProgress[action].append(function)
     280                        self.register_action_progress[action].append(function)
    257281                else:
    258282                        self._debug("Registered process for action: "+action+" and function: "+str(function))
    259                         self.registerProcessProgress[action]=[function]
    260                 if parentAction:
    261                         self._debug("Registered process for Parent Action: "+action+"-"+parentAction+" and function: "+str(function))
    262                         if parentAction in self.threadsProgress.keys():
    263                                 self.threadsProgress[parentAction].update({action:function})
     283                        self.register_action_progress[action]=[function]
     284                if parent_action:
     285                        self._debug("Registered process for Parent Action: "+action+"-"+parent_action+" and function: "+str(function))
     286                        if parent_action in self.threads_progress.keys():
     287                                self.threads_progress[parent_action].update({action:function})
    264288                        else:
    265                                 self.threadsProgress[parentAction]={action:function}
    266         #def _registerProcessProgress
     289                                self.threads_progress[parent_action]={action:function}
     290        #def _register_action_progress
    267291
    268292        ####
     
    275299        def get_progress(self,action=None):
    276300                progress={'search':0,'list':0,'install':0,'remove':0,'load':0,'list_sections':0}
    277                 actionList=[]
    278                 if action and action in self.registerProcessProgress:
    279                         actionList=[action]
    280                 else:
    281                         actionList=self.registerProcessProgress.keys()
     301                action_list=[]
     302                if action and action in self.register_action_progress:
     303                        action_list=[action]
     304                else:
     305                        action_list=self.register_action_progress.keys()
    282306                self.lock.acquire() #prevent that any thread attempts to change the iterator
    283                 for parentAction in self.relatedActions.keys():
    284                         if self.is_action_running(parentAction):
    285                                 for action in actionList:
    286                                         if parentAction in self.threadsProgress.keys():
    287                                                 acumProgress=0
    288                                                 for threadfunction,function in self.threadsProgress[parentAction].items():
    289                                                         acumProgress=acumProgress+function.progress
     307                for parent_action in self.related_actions.keys():
     308                        if self.is_action_running(parent_action):
     309                                for action in action_list:
     310                                        if parent_action in self.threads_progress.keys():
     311                                                acum_progress=0
     312                                                for threadfunction,function in self.threads_progress[parent_action].items():
     313                                                        acum_progress=acum_progress+function.progress
    290314       
    291                                                 count=len(self.relatedActions[parentAction])
    292                                                 self.progressActions[parentAction]=round(acumProgress/count,0)
    293                                                 progress[parentAction]=self.progressActions[parentAction]
     315                                                count=len(self.related_actions[parent_action])
     316                                                self.action_progress[parent_action]=round(acum_progress/count,0)
     317                                                progress[parent_action]=self.action_progress[parent_action]
    294318                        else:
    295319                                #put a 100% just in case
    296                                 if parentAction in self.progressActions.keys():
    297                                         self.progressActions[parentAction]=100
     320                                if parent_action in self.action_progress.keys():
     321                                        self.action_progress[parent_action]=100
    298322                self.lock.release()
    299                 return(self.progressActions)
     323                return(self.action_progress)
    300324        #def get_progress
    301325
     
    328352                                        result[action]=[]
    329353                self.lock.release()
    330                 if action in self.extraActions.keys():
     354                if action in self.extra_actions.keys():
    331355                        self._load_Store()
    332356                return(result)
     
    347371                        result=self.result[action]['status']
    348372                        try:
    349                                 errorFile=open('/usr/share/lliurex-store/files/error.json').read()
    350                                 errorCodes=json.loads(errorFile)
    351                                 errCode=str(result['status'])
    352                                 if errCode in errorCodes:
    353                                         result['msg']=errorCodes[errCode]
     373                                err_file=open('/usr/share/lliurex-store/files/error.json').read()
     374                                err_codes=json.loads(err_file)
     375                                err_code=str(result['status'])
     376                                if err_code in err_codes:
     377                                        result['msg']=err_codes[err_code]
    354378                                else:
    355379                                        result['msg']=u"Unknown error"
     
    364388        ####
    365389        def _load_Store(self):
    366                 if self.loadBundles:
    367                         action='load_bundles'
    368                 else:
    369                         action='load'
    370                 loadFunction=self._execute_class_method(action,None,None)
    371                 self.store=loadFunction.execute_action(action,self.store,self.loadBundles)
     390                action='load'
     391                for package_type in self.plugins_registered[action]:
     392                        load_function=self._execute_class_method(action,package_type,None)
     393                        self.store=load_function.execute_action(action=action,store=self.store)['data']
    372394        #def _load_Store
    373395
     
    381403        def _get_App_Info(self,applist,launchedby=None):
    382404                action='get_info'
    383                 infoFunction=self._execute_class_method(action,None,launchedby)
    384                 applistInfo=infoFunction.execute_action(self.store,action,applist)
    385                 return(applistInfo)
     405                info_function=self._execute_class_method(action,None,launchedby)
     406                info_applist=info_function.execute_action(self.store,action,applist)
     407                return(info_applist)
    386408        #def _get_App_Info
    387409
     
    393415        #  - Dict with the related info
    394416        ####
    395         def _get_Extended_App_Info(self,applistInfo,launchedby=None,fullsearch=True):
     417        def _get_Extended_App_Info(self,info_applist,launchedby=None,fullsearch=True):
    396418                #Check if there's any plugin for the distinct type of packages
    397419                action='pkginfo'
    398                 typeDict={}
     420                types_dict={}
    399421                result={}
    400422                result['data']=[]
    401423                result['status']={'status':0,'msg':''}
    402                 for appInfo in applistInfo:
    403 #                       result['data'].append(appInfo)
    404                         package_type=self._check_package_type(appInfo)
    405                         if package_type in typeDict:
    406                                 typeDict[package_type].append(appInfo)
     424                for app_info in info_applist:
     425#                       result['data'].append(app_info)
     426                        package_type=self._check_package_type(app_info)
     427                        if package_type in types_dict:
     428                                types_dict[package_type].append(app_info)
    407429                        else:
    408                                 typeDict[package_type]=[appInfo]
    409                 for package_type in typeDict:
     430                                types_dict[package_type]=[app_info]
     431                for package_type in types_dict:
    410432                        self._debug("Checking plugin for "+action+ " "+package_type)
    411                         if package_type in self.registeredPlugins[action]:
     433                        if package_type in self.plugins_registered[action]:
    412434#                               result['data']=[]
    413435                                #Only search full info if it's required
    414436                                if (fullsearch==False and package_type=='deb'):
    415                                         result['data'].extend(typeDict[package_type])
     437                                        result['data'].extend(types_dict[package_type])
    416438                                        continue
    417                                 self._debug("Retrieving info for "+str(typeDict[package_type]))
    418                                 pkgInfoFunction=self._execute_class_method(action,package_type,launchedby)
    419 #                               result.update(pkgInfoFunction.execute_action(action,typeDict[package_type]))
    420                                 result['data'].extend(pkgInfoFunction.execute_action(action,typeDict[package_type])['data'])
    421 #                               result['status']=pkgInfoFunction.execute_action(action,typeDict[package_type])['status']
    422 #                               result=pkgInfoFunction.execute_action(action,typeDict[package_type])
     439                                self._debug("Retrieving info for "+str(types_dict[package_type]))
     440                                info_function=self._execute_class_method(action,package_type,launchedby)
     441#                               result.update(info_function.execute_action(action,types_dict[package_type]))
     442                                result['data'].extend(info_function.execute_action(action,types_dict[package_type])['data'])
     443#                               result['status']=info_function.execute_action(action,types_dict[package_type])['status']
     444#                               result=info_function.execute_action(action,types_dict[package_type])
    423445                        else:
    424                                 result['data'].append(appInfo)
     446                                result['data'].append(app_info)
    425447                return(result)
    426448        #def _get_Extended_App_Info
     
    431453                data={}
    432454                status={}
    433                 if action in self.registeredPlugins.keys():
    434                         self._debug("Plugin for generic search: "+self.registeredPlugins[action]['*'])
    435                         finder=self.registeredPlugins[action][('*')]
    436                         searchFunction=eval(finder+"()")
    437                         result=searchFunction.execute_action(self.store,action,searchItem)
     455                if action in self.plugins_registered.keys():
     456                        self._debug("Plugin for generic search: "+self.plugins_registered[action]['*'])
     457                        finder=self.plugins_registered[action][('*')]
     458                        search_function=eval(finder+"()")
     459                        result=search_function.execute_action(self.store,action,searchItem)
    438460                        status=result['status']
    439461                        data=result['data']
     
    452474        #  - List of dicts with all the info
    453475        ####
    454         def _search_Store(self,searchItem='',action='search',fullsearch=False,launchedby=None):
     476        def _search_Store(self,search_item='',action='search',fullsearch=False,launchedby=None,max_results=0):
     477                if type(search_item[-1])==type(1):
     478                        max_results=search_item[-1]
     479                        search_item=search_item[:-1]
    455480                applist={}
    456481                result={}
     
    458483                if action=='list':
    459484                        try:
    460                                 searchItem=' '.join(searchItem)
     485                                search_item=' '.join(search_item)
    461486                        except:
    462                                 searchItem=''
     487                                search_item=''
    463488                elif action=='list_sections':
    464                         searchItem=''
     489                        search_item=''
    465490                elif action=='info':
    466491                        fullsearch=True
     
    471496                if (launchedby=='search'):
    472497                                exact_match=False
    473                 searchFunction=self._execute_class_method(action,'*',launchedby)
    474                 result=searchFunction.execute_action(self.store,action,searchItem,exact_match)
     498                for package_type in self.plugins_registered[action]:
     499                        search_function=self._execute_class_method(action,'*',launchedby)
     500                        result.update(search_function.execute_action(self.store,action,search_item,exact_match,max_results))
    475501                aux_applist=result['data']
    476502                status=result['status']
     
    478504                if status['status']==0:
    479505                        #1.- Get appstream metadata (faster)
    480                         partialAction='get_info'
    481                         self.result[partialAction]={}
     506                        subordinate_action='get_info'
     507                        self.result[subordinate_action]={}
    482508                        result=self._get_App_Info(aux_applist,launchedby)
    483                         self._debug("Add result for "+partialAction)
    484                         self.result[partialAction]=result
     509                        self._debug("Add result for "+subordinate_action)
     510                        self.result[subordinate_action]=result
    485511                        #2.- Get rest of metadata (slower)
    486                         partialAction='pkginfo'
     512                        subordinate_action='pkginfo'
    487513                        result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch)
    488514                        if launchedby:
     
    514540                return_msg=False
    515541                if (self._search_Store(appName,'search',True,action)):
    516                         applistInfo=self.result[action]['data']
    517                         typeDict={}
     542                        info_applist=self.result[action]['data']
     543                        types_dict={}
    518544                        #Check if package is installed if we want to remove it or vice versa
    519                         for appInfo in applistInfo:
     545                        for app_info in info_applist:
    520546#Appstream doesn't get the right status in all cases so we rely on the mechanisms given by the different plugins.
    521                                 if (action=='install' and appInfo['state']=='installed') or (action=='remove' and appInfo['state']=='available'):
    522                                         if (action=='remove' and appInfo['state']=='available'):
    523                                                         self.result[action]['status']={appInfo['package']:3}
     547                                if (action=='install' and app_info['state']=='installed') or (action=='remove' and app_info['state']=='available'):
     548                                        if (action=='remove' and app_info['state']=='available'):
     549                                                        self.result[action]['status']={app_info['package']:3}
    524550                                                        self.result[action]['status']={'status':3}
    525551                                        else:
    526                                                 self.result[action]['status']={appInfo['package']:4}
     552                                                self.result[action]['status']={app_info['package']:4}
    527553                                                self.result[action]['status']={'status':4}
    528554                                                pass
    529555                                        return_msg=False
    530                                         typeDict={}
     556                                        types_dict={}
    531557                                        break
    532558                               
    533                                 package_type=self._check_package_type(appInfo)
    534                                 if package_type in typeDict:
    535                                         typeDict[package_type].append(appInfo)
     559                                package_type=self._check_package_type(app_info)
     560                                if package_type in types_dict:
     561                                        types_dict[package_type].append(app_info)
    536562                                else:
    537                                         typeDict[package_type]=[appInfo]
    538 
    539                         for package_type in typeDict:
     563                                        types_dict[package_type]=[app_info]
     564
     565                        for package_type in types_dict:
    540566                                self._debug("Checking plugin for "+action+ " "+package_type)
    541                                 if package_type in self.registeredPlugins[action]:
    542                                         installFunction=self._execute_class_method(action,package_type,action)
     567                                if package_type in self.plugins_registered[action]:
     568                                        install_function=self._execute_class_method(action,package_type,action)
    543569                                        if package_type=='zmd':
    544570                                        #If it's a zmd the zomando must be present in the system
    545                                                 zmdAppInfo=[]
    546                                                 for zmdPackage in typeDict[package_type]:
     571                                                zmd_info=[]
     572                                                for zmd_bundle in types_dict[package_type]:
    547573                                                        zmdInfo={}
    548                                                         self._debug("Cheking presence of zmd "+ zmdPackage['package'])
    549                                                         zmd='/usr/share/zero-center/zmds/'+appInfo['package']+'.zmd'
     574                                                        self._debug("Cheking presence of zmd "+ zmd_bundle['package'])
     575                                                        zmd='/usr/share/zero-center/zmds/'+app_info['package']+'.zmd'
    550576                                                        if not os.path.exists(zmd):
    551                                                                 zmdInfo['package']=zmdPackage['package']
    552                                                                 zmdAppInfo.append(zmdInfo)
    553                                                 if zmdAppInfo:
     577                                                                zmdInfo['package']=zmd_bundle['package']
     578                                                                zmd_info.append(zmdInfo)
     579                                                if zmd_info:
    554580                                                        self._debug("Installing needed packages")
    555                                                         installAuxFunction=self._execute_class_method(action,"deb",action)
    556                                                         result=installAuxFunction.execute_action(action,zmdAppInfo)
     581                                                        install_depends_function=self._execute_class_method(action,"deb",action)
     582                                                        result=install_depends_function.execute_action(action,zmd_info)
    557583                                                       
    558                                         result=installFunction.execute_action(action,typeDict[package_type])
     584                                        result=install_function.execute_action(action,types_dict[package_type])
    559585                                        self.result[action]=result
    560586                                        if result['status']['status']==0:
    561587                                                #Mark the apps as installed or available
    562                                                 for app in typeDict[package_type]:
     588                                                for app in types_dict[package_type]:
    563589                                                        if action=='install':
    564590                                                                app['appstream_id'].set_state(1)
     
    579605        # - String with the type (deb, sh, zmd...)
    580606        ####
    581         def _check_package_type(self,appInfo):
     607        def _check_package_type(self,app_info):
    582608                #Standalone installers must have the subcategory "installer"
    583609                #Zomandos must have the subcategory "Zomando"
    584                 self._debug("Checking package type for app "+appInfo['name'])
    585                 if "Zomando" in appInfo['categories']:
     610                self._debug("Checking package type for app "+app_info['name'])
     611                if "Zomando" in app_info['categories']:
    586612                        return_msg="zmd"
    587613                else:
    588614                #Standalone installers must have an installerUrl field loaded from a bundle type=script description
    589                         if appInfo['installerUrl']!='':
     615                        if app_info['installerUrl']!='':
    590616                                return_msg="sh"
    591                         elif appInfo['appImage']!='':
    592                                 return_msg="appimage"
     617                        elif app_info['bundle']!='':
     618                                return_msg=app_info['bundle']
    593619                        else:
    594620                                return_msg="deb"
Note: See TracChangeset for help on using the changeset viewer.