Changeset 7432

Timestamp:

Jun 13, 2018, 1:42:39 PM (18 months ago)

Author:

Juanma

Message:

fix wrong update

Location:

lliurex-store/trunk/fuentes

Files:

• debian/changelog (modified) (1 diff)
• lliurex-store-gui/usr/share/lliurex-store/lliurex-store-gui/DetailsBox.py (modified) (1 diff)
• lliurex-store-gui/usr/share/lliurex-store/lliurex-store-gui/ResourcesManager.py (modified) (4 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/appImageManager.py (modified) (11 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py (modified) (1 diff)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/example.py (modified) (2 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/infoManager.py (modified) (8 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/loadStore.py (modified) (4 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/searchManager.py (modified) (4 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/snapManager.py (modified) (16 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/plugins/zmdManager.py (modified) (2 diffs)
• python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py (modified) (12 diffs)

lliurex-store/trunk/fuentes/debian/changelog

@@ +1 @@
+lliurex-store (0.5.4.6) xenial; urgency=medium
+
+  * Fix wrong update
+
+ -- Juanma Navarro Mañez <juanma1980@gmail.com>  Wed, 13 Jun 2018 13:41:28 +0200
+
 lliurex-store (0.5.4.5) xenial; urgency=high
 

lliurex-store/trunk/fuentes/lliurex-store-gui/usr/share/lliurex-store/lliurex-store-gui/DetailsBox.py

@@ -515 +515 @@
         
         def open_clicked(self,widget):
-                if self.core.main_window.current_pkg["bundle"]=='snap':
-                        snap=self.core.main_window.current_pkg["name"]
+                if self.core.main_window.current_pkg["name"].endswith('.snap'):
+                        snap=self.core.main_window.current_pkg["name"].replace('.snap','')
                         if os.path.exists("/snap/bin/%s"%snap):
                                 os.system("/snap/bin/%s"%snap)
-                elif self.core.main_window.current_pkg["bundle"]=='appimage':
-                        appimg=self.core.main_window.current_pkg["package"]
-                        if os.path.exists(os.getenv("HOME")+"/.lliurex-store/appimg/%s"%appimg):
-                                os.system(os.getenv("HOME")+"/.lliurex-store/appimg/%s"%appimg)
+                elif self.core.main_window.current_pkg["name"].endswith('.appimage'):
+                        appimg=self.core.main_window.current_pkg["name"].lower()
+                        if os.path.exists(os.getenv("HOME")+"/.local/bin/%s"%appimg):
+                                os.system(os.getenv("HOME")+"/.local/bin/%s"%appimg)
+                elif 'Zomando' in self.core.main_window.current_pkg["categories"]:
+                        zmd=self.core.main_window.current_pkg["id"]+".zmd"
+                        if os.path.exists("/usr/share/zero-center/zmds/%s"%zmd):
+                                os.system("pe /usr/share/zero-center/zmds/%s"%zmd)
                 else:
                         desktop=self.core.main_window.current_pkg["id"]

lliurex-store/trunk/fuentes/lliurex-store-gui/usr/share/lliurex-store/lliurex-store-gui/ResourcesManager.py

@@ -5 +5 @@
 import time
 import json
-
+import re
 import gi
 gi.require_version('Gtk', '3.0')
@@ -43 +43 @@
                 if os.path.isfile(icon):
                         return(icon)
+
+                if icon.startswith("http"):
+                        cache_dir=os.getenv("HOME")+"/.cache/lliurex-store/icons"
+                        icon_name=icon.split("/")[-1]
+                        if not os.path.exists(cache_dir):
+                                os.makedirs(cache_dir)
+                        if os.path.isfile(cache_dir+"/"+icon_name):
+                                return(cache_dir+"/"+icon_name)
+                        icon_file=cache_dir+"/"+icon_name
+                        url=icon
+                        try:
+                                req=urllib2.Request(url,headers=HEADER)
+                                res=urllib2.urlopen(req)
+                                x=open(icon_file,"wb")
+                                x.write(res.read())
+                                x.close()
+                        except Exception as e:
+                                icon_file=''
+                        finally:
+                                return(icon_file)
+        
                 
                 component=pkg_info["component"]
@@ -55 +76 @@
                         for dist in ["xenial-updates","xenial-security","xenial"]:
                                 # "64x64/" is included in pkg_info["icon"]
-                                if "64x64/" not in icon:
+#                               if "64x64/" not in icon:
+                                if not re.match("[0-9]*x[0-9]*\/",icon):
                                         icon="64x64/" + icon
                                         if debian_name+"_"+debian_name not in icon:
                                                 icon=icon.replace(debian_name,debian_name+"_"+debian_name)
+                                                if not icon.endswith(".png"):
+                                                        icon=icon+'.png'
                                         if "pyromaths" in icon:
                                                 icon="64x64/pyromaths_pyromaths.png"
@@ -64 +88 @@
                                 ret_icon=self.icons_path+"%s/%s"%(component,icon)
                                 if os.path.exists(ret_icon):
-                                        
                                         return ret_icon
+                                else:
+                                        ret_icon=ret_icon.replace("64x64","128x128")
+                                        if os.path.exists(ret_icon):
+                                                return ret_icon
+                                        icon="64x64/" + pkg_info['icon']
+                                ret_icon=self.icons_path+"%s/%s"%(component,icon)
+                                if os.path.exists(ret_icon):
+                                        return ret_icon
+                                else:
+                                #Last attempt
+                                        pkg_id=pkg_info['id'].split('.')[-2]
+                                        icon="64x64/%s_%s.png"%(debian_name,pkg_id)
+                                ret_icon=self.icons_path+"%s/%s"%(component,icon)
+                                if os.path.exists(ret_icon):
+                                        return ret_icon
+                                else:
+                                #Unaccurate icon search... 
+                                        for icon_file in os.listdir(self.icons_path+"/"+component+"/64x64/"):
+                                                if re.search("^.*"+pkg_info['icon']+".*\.png",icon_file):
+                                                        ret_icon=self.icons_path+"%s/64x64/%s"%(component,icon_file)
+                                                        return ret_icon
+                                                                
 
                 ret_icon=self.package_icon

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/appImageManager.py

@@ -1 +1 @@
 #The name of the main class must match the file name in lowercase
+import re
 import urllib
 from urllib.request import Request
@@ -6 +7 @@
 import json
 import os
-from subprocess import call
 import sys
 import threading
-from bs4 import BeautifulSoup
+import queue
+import time
 import random
-import time
 import gi
 from gi.repository import Gio
 gi.require_version('AppStreamGlib', '1.0')
 from gi.repository import AppStreamGlib as appstream
+from bs4 import BeautifulSoup
+#from subprocess import call
 
 class appimagemanager:
         def __init__(self):
-                self.dbg=False
+                self.dbg=True
                 self.progress=0
                 self.partial_progress=0
@@ -26 +28 @@
                 self.result['data']={}
                 self.result['status']={}
-                self.conf_dir=os.getenv("HOME")+"/.cache/lliurex-store"
-                self.bundles_dir=self.conf_dir+"/bundles"
+                self.cache_dir=os.getenv("HOME")+"/.cache/lliurex-store"
+                self.icons_dir=self.cache_dir+"/icons"
+                self.bundles_dir=self.cache_dir+"/xmls/appimage"
                 self.bundle_types=['appimg']
-                self.appimage_dir=os.getenv("HOME")+"/.local/bin/"
+#               self.appimage_dir=os.getenv("HOME")+"/.lliurex-store/appimg"
+                self.appimage_dir=os.getenv("HOME")+"/.local/bin"
                 #To get the description of an app we must go to a specific url defined in url_info.
                 #$(appname) we'll be replaced with the appname so the url matches the right one.
                 #If other site has other url naming convention it'll be mandatory to define it with the appropiate replacements
-                self.repos={'probono':{'url':'https://dl.bintray.com/probono/AppImages', 'url_info':'https://bintray.com/probono/AppImages/$(appname)'}}
-                #Appimges not stored in a repo must be listed here, providing the download url and the info url (if there's any)
+                self.repos={'appimagehub':{'type':'json','url':'https://appimage.github.io/feed.json','url_info':''}}
+                #Appimges not stored in a repo must be listed in this file, providing the download url and the info url (if there's any)
                 self.external_appimages="/usr/share/lliurex-store/files/external_appimages.json"
+                self.locale=['ca_ES@valencia','ca@valencia','qcv','ca','ca_ES','es_ES','es','en_US','en_GB','en','C']
                 self.disabled=False
-                self.count=0
+                self.icon_cache_enabled=True
+                self.image_cache_enabled=True
+                self.apps_for_store=queue.Queue()
         #def __init__
 
@@ -61 +68 @@
                 else:
                         self.store=appstream.Store()
+                self.appimage_store=appstream.Store()
                 self.progress=0
                 self.result['status']={'status':-1,'msg':''}
-                self.result['data']=''
+                self.result['data']=[]
+                self.threads=[]
                 dataList=[]
                 if self.disabled:
@@ -71 +80 @@
                         self._chk_installDir()
                         if action=='load':
-                                self.result['data']=self._load_appimage_store(self.store)
+                                self._load_appimage_store()
+#                               self.result['data']=self._load_appimage_store()
+                                #wait till threads end (if any)
+                                self._debug("Ending threads...")
+#                               for app in self.apps_for_store:
+                                for th in threading.enumerate():
+                                        if th.is_alive():
+                                                try:
+                                                        th.join(5)
+                                                except:
+                                                        pass
+                                while not self.apps_for_store.empty():
+                                        app=self.apps_for_store.get()
+                                        self.store.add_app(app)
+                                self.result['data']=self.store
                         else:
                                 for app_info in applist:
@@ -81 +104 @@
                                         if action=='pkginfo':
                                                 dataList.append(self._get_info(app_info))
-                                        self.progress+=int(self.partial_progress/len(applist))
+                                        self.progress+=int(self.partial_progress/len(applist))-1
                                 self.result['data']=list(dataList)
                 self.progress=100
@@ -118 +141 @@
                         self._set_status(4)
                 else:
-                                #                       appimage_url=self.repository_url+'/'+app_info['package']
-                        appimage_url=app_info['homepage']+'/'+app_info['package']
+#                       appimage_url=app_info['installerUrl']+'/'+app_info['package']
+                        appimage_url=app_info['channel_releases']['appimage'][0]
                         self._debug("Downloading "+appimage_url)
                         dest_path=self.appimage_dir+'/'+app_info['package']
@@ -163 +186 @@
         #def _remove_appimage
 
-        def _get_info(self,app_info):
-                app_info['state']='available'
-                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
-                        app_info['state']='installed'
-                #Get size
-                appimage_url=app_info['homepage']+'/'+app_info['package']
-                dest_path=self.appimage_dir+'/'+app_info['package']
-                if appimage_url:
-                        try:
-                                with urllib.request.urlopen(appimage_url) as response:
-                                        app_info['size']=(response.info()['Content-Length'])
-                        except:
-                                app_info['size']=0
-                self._set_status(0)
-                self.partial_progress=100
-                return(app_info)
-        #def _get_info
-
-        def _load_appimage_store(self,store):
-                self._download_bundles_catalogue()
+        def _load_appimage_store(self,store=None):
+                self._get_bundles_catalogue()
                 if os.path.exists(self.bundles_dir):
                         for bundle_type in self.bundle_types:
@@ -207 +212 @@
         #def _generic_file_load
 
-        def _download_bundles_catalogue(self):
-                CURSOR_UP='\033[F'
-                ERASE_LINE='\033[K'
-                content=''
+        def _get_bundles_catalogue(self):
                 applist=[]
-                progress_bar="#"
-                self.descriptions_dict={}
+                appdict={}
                 all_apps=[]
                 outdir=self.bundles_dir+'/appimg/'
                 #Load repos
                 for repo_name,repo_info in self.repos.items():
-                        if self._chk_bundle_dir(outdir):
-                                self._debug("Fetching repo %s"%repo_info['url'])
-##                                      print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
-##                                      progress_bar=progress_bar+"#"
-##                                      print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
-                                applist=self._generate_applist(self._fetch_repo(repo_info['url']),repo_name)
-##                                      progress_bar=progress_bar+"##"
-##                                      print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
-                                self._debug("Processing info...")
-                                self._th_generate_xml_catalog(applist,outdir,repo_info['url_info'],repo_info['url'],repo_name,progress_bar)
-                                self._debug("Fetched repo "+repo_info['url'])
-                                all_apps.extend(applist)
-                        else:
+                        if not os.path.isdir(self.bundles_dir):
+                                try:
+                                        os.makedirs(self.bundles_dir)
+                                except:
                                         self._debug("appImage catalogue could not be fetched: Permission denied")
+                        self._debug("Fetching repo %s"%repo_info['url'])
+                        if repo_info['type']=='json':
+                                applist=self._process_appimage_json(self._fetch_repo(repo_info['url']),repo_name)
+
+                        self._debug("Fetched repo "+repo_info['url'])
+                        self._th_generate_xml_catalog(applist,outdir,repo_info['url_info'],repo_info['url'],repo_name)
+                        all_apps.extend(applist)
                 #Load external apps
                 for app_name,app_info in self._get_external_appimages().items():
-                        if self._chk_bundle_dir(outdir):
-                                appimage=app_info['url'].split('/')[-1]
-                                appimage_url='/'.join(app_info['url'].split('/')[0:-1])
+                        if os.path.isdir(self.bundles_dir):
+                                appinfo=self._init_appinfo()
+                                appinfo['name']=app_info['url'].split('/')[-1]
+                                appinfo['package']=app_info['url'].split('/')[-1]
+                                appinfo['homepage']='/'.join(app_info['url'].split('/')[0:-1])
                                 self._debug("Fetching external appimage %s"%app_info['url'])
-                                applist=[appimage]
-                                self._debug("Processing info...")
-                                self._th_generate_xml_catalog(applist,outdir,app_info['url_info'],appimage_url,app_name,progress_bar)
+                                appinfo['bundle']='appimage'
+                                applist=[appinfo]
+                                self._th_generate_xml_catalog(applist,outdir,app_info['url_info'],app_info['url'],app_name)
                                 self._debug("Fetched appimage "+app_info['url'])
                                 all_apps.extend(applist)
                         else:
                                 self._debug("External appImage could not be fetched: Permission denied")
-
-
-##              print (("Removing old entries..."))
-                self._clean_bundle_catalogue(all_apps,outdir)
+                self._debug("Removing old entries...")
+#               self._clean_bundle_catalogue(all_apps,outdir)
                 return(True)
-        #def _download_bundles_catalogue
-
+        #def _get_bundles_catalogue
+        
+        def _fetch_repo(self,repo):
+                req=Request(repo, headers={'User-Agent':'Mozilla/5.0'})
+                with urllib.request.urlopen(req) as f:
+                        content=(f.read().decode('utf-8'))
+                
+                return(content)
+        #def _fetch_repo
+        
         def _get_external_appimages(self):
                 external_appimages={}
@@ -262 +269 @@
                 self._debug(external_appimages)
                 return external_appimages
-
+        #def _get_external_appimages
+        
+        def _process_appimage_json(self,data,repo_name):
+                applist=[]
+                json_data=json.loads(data)
+                if 'items' in json_data.keys():
+                        for appimage in json_data['items']:
+                                appinfo=self._th_process_appimage(appimage)
+                                if appinfo:
+                                        applist.append(appinfo)
+                return (applist)
+        #_process_appimage_json
+
+        def _th_process_appimage(self,appimage):
+                appinfo=None
+                releases=[]
+                if 'links' in appimage.keys():
+                        if appimage['links']:
+                                appinfo=self.load_json_appinfo(appimage)
+#Deprecated. appImage releases will be load on the info stage
+#                       releases=self._get_releases_from_json(appimage)
+#                       if releases:
+#                               appinfo['releases']=releases
+#                               for release in releases:
+#                                       #Release has the direct download url
+#                                       tmp_release=release.split('/')
+#                                       tmp_appinfo=appinfo.copy()
+#                                       rel_number=tmp_release[-2]
+#                                       rel_name=tmp_release[-1].lower().replace('.appimage','')
+#                                       self._debug("Release: %s"%release)
+#                                       tmp_appinfo['name']=rel_name
+#                                       tmp_appinfo['package']=tmp_release[-1]
+#                                       tmp_appinfo['homepage']='/'.join(tmp_release[0:-1])
+#                                       self.queue.put(tmp_appinfo)
+                return(appinfo)
+        #def _th_process_appimage
+
+        def load_json_appinfo(self,appimage):
+                appinfo=self._init_appinfo()
+                appinfo['name']=appimage['name']
+                appinfo['package']=appimage['name']
+                if 'license' in appimage.keys():
+                        appinfo['license']=appimage['license']
+                appinfo['summary']=''
+                if 'description' in appimage.keys():
+                        appinfo['description']=appimage['description']
+                if 'categories' in appimage.keys():
+                        appinfo['categories']=appimage['categories']
+                if 'icon' in appimage.keys():
+                        appinfo['icon']=appimage['icon']
+                if 'icons' in appimage.keys():
+                        self._debug("Loading icon %s"%appimage['icons'])
+                        if appimage['icons']:
+                                self._debug("Loading icon %s"%appimage['icons'][0])
+                                appinfo['icon']=appimage['icons'][0]
+                if 'screenshots' in appimage.keys():
+                        appinfo['thumbnails']=appimage['screenshots']
+                if 'links' in appimage.keys():
+                        if appimage['links']:
+                                for link in appimage['links']:
+                                        if 'url' in link.keys() and link['type']=='Download':
+                                                appinfo['installerUrl']=link['url']
+                if 'authors' in appimage.keys():
+                        if appimage['authors']:
+                                for author in appimage['authors']:
+                                        if 'url' in author.keys():
+                                                self._debug("Author: %s"%author['url'])
+                                                appinfo['homepage']=author['url']
+                else:
+                        appinfo['homepage']='/'.join(appinfo['installerUrl'].split('/')[0:-1])
+                appinfo['bundle']=['appimage']
+                return appinfo
+        #def load_json_appinfo
+
+        def _th_generate_xml_catalog(self,applist,outdir,info_url,repo,repo_name):
+                maxconnections = 2
+                threads=[]
+                semaphore = threading.BoundedSemaphore(value=maxconnections)
+                random_applist = list(applist)
+                random.shuffle(random_applist)
+                for app in applist:
+                        th=threading.Thread(target=self._th_write_xml, args = (app,outdir,info_url,repo,repo_name,semaphore))
+                        threads.append(th)
+                        th.start()
+        #def _th_generate_xml_catalog
+
+        def     _th_write_xml(self,appinfo,outdir,info_url,repo,repo_name,semaphore):
+                semaphore.acquire()
+                self._add_appimage(appinfo)
+                semaphore.release()
+        #def _th_write_xml
+
+#       def _add_appimage(self,appinfo,repo_info):
+        def _add_appimage(self,appinfo):
+                #Search in local store for the app
+                sw_new=False
+                app=appstream.App()
+                app_orig=self.store.get_app_by_pkgname(appinfo['package'].lower())
+                if not app_orig:
+                        app_orig=self.store.get_app_by_id(appinfo['package'].lower()+".desktop")
+                if app_orig:
+                        self._debug("Extending app %s"%appinfo['package'])
+                        app=self._copy_app_from_appstream(app_orig,app)
+                else:
+                        self._debug("Generating new %s"%appinfo['package'])
+                app.set_id("appimagehub.%s"%appinfo['name'].lower()+'.appimage')
+                app.set_id_kind=appstream.IdKind.DESKTOP
+                sw_new=True
+
+                icon=appstream.Icon()
+                screenshot=appstream.Screenshot()
+                app.set_name("C",appinfo['name']+".appimage")
+                app.add_pkgname(appinfo['package'].lower()+".appimage")
+                if appinfo['license']:
+                        app.set_project_license(appinfo['license'])
+                bundle=appstream.Bundle()
+                bundle.set_kind(bundle.kind_from_string('APPIMAGE'))
+                bundle.set_id(appinfo['package']+'.appimage')
+#               if app_orig:
+#                       app_orig.add_bundle(bundle)
+                app.add_bundle(bundle)
+                app.add_keyword("C","appimage")
+                app.add_category("appimage")
+                app.add_url(appstream.UrlKind.UNKNOWN,appinfo['installerUrl'])
+                app.add_url(appstream.UrlKind.HOMEPAGE,appinfo['homepage'])
+                if sw_new:
+                        app.add_keyword("C",appinfo['package'])
+                        app.set_name("C",appinfo['name']+".appimage")
+                        description="This is an AppImage bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully.\n%s"%(appinfo['name'],appinfo['description'])
+                        summary=' '.join(list(description.split(' ')[:8]))
+                        if len(description.split(' '))>8:
+                                summary+="... "
+                        app.set_description("C",description)
+                        app.set_comment("C",summary)
+                        for category in appinfo['categories']:
+                                app.add_category(category)
+                if appinfo['icon']:
+                        if self.icon_cache_enabled:
+                                icon.set_kind(appstream.IconKind.LOCAL)
+                                icon.set_name(self._download_file(appinfo['icon'],appinfo['name'],self.icons_dir))
+                        else:
+                                icon.set_kind(appstream.IconKind.REMOTE)
+                                icon.set_name(pkg.get_icon())
+                                icon.set_url(pkg.get_icon())
+                        app.add_icon(icon)
+                if appinfo['thumbnails']:
+                        img=appstream.Image()
+                        if not appinfo['thumbnails'][0].startswith('http'):
+                                        appinfo['screenshot']=appinfo['thumbnails'][0]
+                                        appinfo['screenshot']="https://appimage.github.io/database/%s"%appinfo['screenshot']
+                        img.set_kind(appstream.ImageKind.SOURCE)
+                        img.set_url(appinfo['screenshot'])
+                        screenshot.add_image(img)
+                        app.add_screenshot(screenshot)
+                #Adds the app to the store
+#               self._debug("Adding %s"%appinfo['package'])
+                self.apps_for_store.put(app)
+                if not os.path.isfile(self.bundles_dir+'/'+app.get_id_filename()):
+                        gioFile=Gio.File.new_for_path('%s/%s.xml'%(self.bundles_dir,app.get_id_filename()))
+                        app.to_file(gioFile)
+        #def _add_appimage
+
+        def _copy_app_from_appstream(self,app_orig,app):
+                app.set_id("appimage."+app_orig.get_id())
+                for category in app_orig.get_categories():
+                        app.add_category(category)
+                for screenshot in app_orig.get_screenshots():
+                        app.add_screenshot(screenshot)
+                for icon in app_orig.get_icons():
+                        app.add_icon(icon)
+                for localeItem in self.locale:
+                        if app_orig.get_name(localeItem):
+                                app.set_name(localeItem,app_orig.get_name(localeItem)+".appimage")
+                        if app_orig.get_description(localeItem):
+                                app.set_description(localeItem,app_orig.get_description(localeItem))
+                        if app_orig.get_comment(localeItem):
+                                app.set_comment(localeItem,app_orig.get_comment(localeItem))
+                app.set_origin(app_orig.get_origin())
+                return app
+
+        def _clean_bundle_catalogue(self,applist,outdir):
+                xml_files_list=[]
+                applist=[item.lower() for item in applist]
+                for xml_file in os.listdir(outdir):
+                        if xml_file.endswith('appdata.xml'):
+                                xml_files_list.append(xml_file.lower().replace('appdata.xml','appimage'))
+        
+                if xml_files_list:
+                        xml_discard_list=list(set(xml_files_list).difference(applist))
+                        for discarded_file in xml_discard_list:
+                                os.remove(outdir+'/'+discarded_file.replace('appimage','appdata.xml'))
+        #def _clean_bunlde_catalogue
+
+        def _download_file(self,url,app_name,dest_dir):
+#               target_file=self.icons_folder+'/'+app_name+".png"
+                target_file=dest_dir+'/'+app_name+".png"
+                if not url.startswith('http'):
+                        url="https://appimage.github.io/database/%s"%url
+                if not os.path.isfile(target_file):
+#                       shutil.copy("/usr/share/icons/hicolor/128x128/apps/lliurex-store.png",target_file)
+#                       if not os.fork():
+                        if not os.path.isfile(target_file):
+                                self._debug("Downloading %s to %s"%(url,target_file))
+                                try:
+                                        with urllib.request.urlopen(url) as response, open(target_file, 'wb') as out_file:
+                                                bf=16*1024
+                                                acumbf=0
+                                                file_size=int(response.info()['Content-Length'])
+                                                while True:
+                                                        if acumbf>=file_size:
+                                                            break
+                                                        shutil.copyfileobj(response, out_file,bf)
+                                                        acumbf=acumbf+bf
+                                        st = os.stat(target_file)
+                                except Exception as e:
+                                        self._debug("Unable to download %s"%url)
+                                        self._debug("Reason: %s"%e)
+                                        target_file=''
+#                               os._exit(0)
+                return(target_file)
+        #def _download_file
+        
         def _chk_bundle_dir(self,outdir):
                 msg_status=True
@@ -273 +501 @@
                 return(os.access(outdir,os.W_OK|os.R_OK|os.X_OK|os.F_OK))
         #def _chk_bundle_dir
-
-        def _fetch_repo(self,repo):
-                req=Request(repo, headers={'User-Agent':'Mozilla/5.0'})
-                with urllib.request.urlopen(req) as f:
-                        content=(f.read().decode('utf-8'))
-                
-                return(content)
-        #def _fetch_repo
-
-        def _generate_applist(self,content,repo_name):
-                garbage_list=[]
-                applist=[]
-                #webscrapping for probono repo
-                if repo_name=='probono':
-                        garbage_list=content.split(' ')
-                        for garbage_line in garbage_list:
-                                if garbage_line.endswith('AppImage"'):
-                                        app=garbage_line.replace('href=":','')
-                                        applist.append(app.replace('"',''))
-                #Example of a webscrapping from another site
-#               if repo_name='other_repo_name':
-#                       for garbage_line in garbage_list:
-#                                       if garbage_line.startswith('file="'):
-#                                               if 'appimage' in garbage_line:
-#                                                       app=garbage_line.replace('file="','')
-#                                                       app=app.replace('\n','')
-#                                                       self._debug("Add %s"%app)
-#                                                       applist.append(app.replace('"',''))
-
-                return(applist)
-        #def _generate_applist
-
-        def _th_generate_xml_catalog(self,applist,outdir,info_url,repo,repo_name,progress_bar=''):
-                CURSOR_UP='\033[F'
-                ERASE_LINE='\033[K'
-                maxconnections = 10
-                semaphore = threading.BoundedSemaphore(value=maxconnections)
-                random_applist = list(applist)
-                random.shuffle(random_applist)
-                len_applist=len(random_applist)
-                inc=30/len_applist
-#               print (CURSOR_UP)
-                for app in random_applist:
-                        th=threading.Thread(target=self._th_write_xml, args = (app,outdir,info_url,repo,repo_name,semaphore,inc))
-                        th.start()
-#               os.system('setterm -cursor off')
-#               while threading.active_count()>2: #Discard both main and own threads
-#                       for i in range(len(progress_bar),int(self.progress)):
-#                               progress_bar='#'+progress_bar
-#                       print (CURSOR_UP)
-#                       print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
-#               os.system('setterm -cursor on')
-        #def _th_generate_xml_catalog
-
-        def _th_write_xml(self,app,outdir,info_url,repo,repo_name,semaphore,inc):
-                semaphore.acquire()
-                lock=threading.Lock()
-                name_splitted=app.split('-')
-                name=name_splitted[0]
-                version=name_splitted[1]
-                arch=name_splitted[2]
-                filename=outdir+app.lower().replace('appimage',"appdata.xml")
-                self._debug("checking if we need to download "+filename)
-                if not os.path.isfile(filename):
-                        self._write_xml_file(filename,app,name,version,info_url,repo,repo_name,lock)
-                with lock:
-                        self.progress=self.progress+inc
-                semaphore.release()
-        #def _th_write_xml
-
-        def _write_xml_file(self,filename,app,name,version,info_url,repo,repo_name,lock):
-                        self._debug("Generating "+app+" xml")
-                        f=open(filename,'w')
-                        f.write('<?xml version="1.0" encoding="UTF-8"?>'+"\n")
-                        f.write("<components version=\"0.10\">\n")
-                        f.write("<component  type=\"desktop-application\">\n")
-                        f.write("  <id>"+app.lower()+"</id>\n")
-                        f.write("  <pkgname>"+app+"</pkgname>\n")
-                        f.write("  <name>"+name+"</name>\n")
-                        f.write("  <metadata_license>CC0-1.0</metadata_license>\n")
-                        f.write("  <provides><binary>"+app+"</binary></provides>\n")
-                        f.write("  <releases>\n")
-                        f.write("  <release version=\""+version+"\" timestamp=\"1408573857\"></release>\n")
-                        f.write("  </releases>\n")
-                        f.write("  <launchable type=\"desktop-id\">"+name+".desktop</launchable>\n")
-                        with lock:
-                                try:
-                                        if name in self.descriptions_dict.keys():
-                                                description=self.descriptions_dict[name]
+        
+        def _init_appinfo(self):
+                appInfo={'appstream_id':'',\
+                'id':'',\
+                'name':'',\
+                'version':'',\
+                'channel_releases':{},\
+                'component':'',\
+                'package':'',\
+                'license':'',\
+                'summary':'',\
+                'description':'',\
+                'categories':[],\
+                'icon':'',\
+                'screenshot':'',\
+                'thumbnails':[],\
+                'video':'',\
+                'homepage':'',\
+                'installerUrl':'',\
+                'state':'',\
+                'depends':'',\
+                'kudos':'',\
+                'suggests':'',\
+                'extraInfo':'',\
+                'size':'',\
+                'bundle':'',\
+                'updatable':'',\
+                }
+                return(appInfo)
+        #def _init_appinfo
+        
+        def _get_info(self,app_info):
+                if app_info['installerUrl']:
+                        app_info['channel_releases']={'appimage':[]}
+                        app_info['channel_releases']['appimage']=self._get_releases(app_info)
+                app_info['state']='available'
+                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
+                        app_info['state']='installed'
+                #Get size
+                if 'appimage' in app_info['channel_releases'].keys():
+                        if app_info['channel_releases']['appimage'][0]:
+                                appimage_url=app_info['channel_releases']['appimage'][0]
+                                dest_path=self.appimage_dir+'/'+app_info['package']
+                                if appimage_url:
+                                        try:
+                                                with urllib.request.urlopen(appimage_url) as response:
+                                                        app_info['size']=(response.info()['Content-Length'])
+                                        except:
+                                                app_info['size']=0
+                        else:
+                                app_info['size']=0
+                        #Version (unaccurate aprox)
+                        app_info['version']=app_info['channel_releases']['appimage'][0].split('/')[-2]
+#                       try:
+#                               app_info['version']="%s.%s"%(version.split('.')[1],version.split('.')[2])
+#                       except:
+#                               app_info['version']="%s"%version.split('_')[-1]
+
+                self._set_status(0)
+                self.partial_progress=100
+                return(app_info)
+        #def _get_info
+
+        def _get_releases(self,app_info):
+                releases=[]
+                releases_page=''
+                self._debug("Info url: %s"%app_info['installerUrl'])
+                url_source=""
+                try:
+                        if 'github' in app_info['installerUrl']:
+                                releases_page="https://github.com"
+                        if 'gitlab' in app_info['installerUrl']:
+                                releases_page="https://gitlab.com"
+                        if 'opensuse' in app_info['installerUrl'].lower():
+                                releases_page=""
+                                url_source="opensuse"
+#                               app_info['installerUrl']=app_info['installerUrl']+"/download"
+
+                        with urllib.request.urlopen(app_info['installerUrl']) as f:
+                                content=(f.read().decode('utf-8'))
+                                soup=BeautifulSoup(content,"html.parser")
+                                package_a=soup.findAll('a', attrs={ "href" : re.compile(r'.*\.[aA]pp[iI]mage$')})
+
+                                for package_data in package_a:
+                                        if url_source=="opensuse":
+                                                package_name=package_data.findAll('a', attrs={"class" : "mirrorbrain-btn"})
                                         else:
-                                                description=self._get_description(name,info_url,repo_name)
-                                                self.descriptions_dict.update({name:description})
-                                except:
-                                        description=''
-                        summary=' '.join(list(description.split(' ')[:8]))
-                        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.\n"+description
-                        if not summary:
-                                summary=' '.join(list(description.split(' ')[:8]))
-                        f.write("  <description><p></p><p>"+description+"</p></description>\n")
-                        f.write("  <summary>"+summary+"...</summary>\n")
-                        f.write('  <url type="homepage">'+repo+'</url>\n')
-                        f.write("  <bundle type=\"appimage\">"+app+"</bundle>\n")
-                        f.write("  <keywords>\n")
-                        f.write("       <keyword>"+name+"</keyword>\n")
-                        f.write("       <keyword>appimage</keyword>\n")
-                        f.write("  </keywords>\n")
-                        f.write("  <categories>\n")
-                        f.write("       <category>AppImage</category>\n")
-#                       f.write("       <category>GTK</category>\n")
-                        f.write("  </categories>\n")
-                        f.write("<icon type=\"cached\">"+name+"_"+name+".png</icon>\n")
-                        f.write("</component>\n")
-                        f.write("</components>\n")
-                        f.close()
-        #def _write_xml_file
-
-        def _get_description(self,app_name,info_url,repo_name):
-                desc=''
-                if '$(appname)' in info_url:
-                        info_url=info_url.replace('$(appname)',app_name)
-                if info_url:
-                        self._debug("Getting description from repo/app %s - %s "%(repo_name,info_url))
-                        try:
-                                with urllib.request.urlopen(info_url) as f:
-                                        if repo_name=='probono':
-                                                content=(f.read().decode('utf-8'))
-                                                soup=BeautifulSoup(content,"html.parser")
-                                                description_div=soup.findAll('div', attrs={ "class" : "description-text"})
-                                if len(description_div)>0:
-                                        desc=description_div[0].text
-                                        desc=desc.replace(':','.')
-                                        desc=desc.replace('&','&amp;')
-                        except Exception as e:
-                                print("Can't get description from "+info_url)
-                                print(str(e))
-                                pass
-                return(desc)
-        #def _get_description
-
-        def _clean_bundle_catalogue(self,applist,outdir):
-                xml_files_list=[]
-                applist=[item.lower() for item in applist]
-                for xml_file in os.listdir(outdir):
-                        if xml_file.endswith('appdata.xml'):
-                                xml_files_list.append(xml_file.lower().replace('appdata.xml','appimage'))
-        
-                if xml_files_list:
-                        xml_discard_list=list(set(xml_files_list).difference(applist))
-                        for discarded_file in xml_discard_list:
-                                os.remove(outdir+'/'+discarded_file.replace('appimage','appdata.xml'))
-        #def _clean_bunlde_catalogue
-
+                                                package_name=package_data.findAll('strong', attrs={ "class" : "pl-1"})
+                                        package_link=package_data['href']
+                                        if releases_page or url_source:
+                                                package_link=releases_page+package_link
+                                                releases.append(package_link)
+                                                self._debug("Link: %s"%package_link)
+                except Exception as e:
+                        print(e)
+                return releases
+        #def _get_releases
+        

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/debManager.py

@@ -6 +6 @@
         def __init__(self):
                 self.installer=''
-                self.dbg=False
+                self.dbg=True
                 self.result=[]
                 self.progress=0

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/example.py

@@ -8 +8 @@
                 self.progress=0
                 #This dict defines wich package_type relies on what action
-                #actions are defined in storeManager. 
+                #actions could be defined in storeManager or per-plugin
                 #Non contempled actions must declare its related functions on storeManager (threads dict) and define relationships with other actions in relatedActions.
-                #action=example
-                #package='*' (in this case all package_types. It could be "deb", "zmd" or whatever package type)
+                #package='*' (in this case action 'example' is related to all package_types. It could be "deb", "zmd" or whatever package type)
                 self.plugin_actions={'example':'*'}
-                #This switch enables cli_mode for the plugin, just in case some function difers from the gui mode
+                #This switch enables cli_mode for the plugin, just in case some function difers from the gui mode (take a look at snapManager)
                 self.cli_mode=False
                 #This one controls if the plugin is enabled or not
@@ -19 +18 @@
                 # - storeManager having a parameter with name=package_type (simply add it to the arg list passed when invoking storeManager)
                 # - Internal failure controls (see zmdManager for an example)
+                #If there'll be no parameter for enable/disable then the plugin manages it's own state and self.disabled must be None
                 #This example plugin is disabled by default
                 self.disabled=True

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/infoManager.py

@@ -3 +3 @@
 class infomanager:
         def __init__(self):
-                self.dbg=False
+                self.dbg=True
                 self.plugin_actions={'get_info':'*'}
                 self.result={}
@@ -60 +60 @@
                         appInfo=self._init_appInfo()
 #                       self._debug("Gathering package info for "+app.get_id())
-                        appInfo['appstream_id']=app
+#Earlier versions stored the appstream_id as the memory dir of the metadata
+#Changes in python3.6 and pickle module forces us to disable this feature... 
+#                       appInfo['appstream_id']=app
                         if app.get_id():
                                 appInfo['id']=app.get_id()
@@ -75 +77 @@
                         if app.get_pkgname_default():
                                 appInfo['package']=app.get_pkgname_default()
+                        if len(app.get_pkgnames())>1:
+                                appInfo['packages']=app.get_pkgnames()
                         if app.get_project_license():
                                 appInfo['license']=app.get_project_license()
@@ -94 +98 @@
                                 appInfo['categories']=app.get_categories()
                         if app.get_icon_default():
-                                appInfo['icon']=app.get_icon_default().get_name()
+                                if app.get_icon_default().get_filename():
+                                        appInfo['icon']=app.get_icon_default().get_filename()
+                                else:
+                                        appInfo['icon']=app.get_icon_default().get_name()
                                 if appInfo['icon']==None:
                                         icons=app.get_icons()
@@ -103 +110 @@
                                         else:
                                                 appInfo['icon']=''
-                                
+                        if appInfo['icon']==None:       
+                                appInfo['icon']=''
                         if app.get_screenshots():       
                                 thumbnails_list=[]
@@ -134 +142 @@
                                 appInfo["screenshots"]=screenshots_list
                         #The values are the values of appstream.UrlKind. 1=HOMEPAGE, 0=UNKNOWN
+#                       self._debug(app.get_url_item(0))
                         if app.get_url_item(1):
                                 appInfo['homepage']=app.get_url_item(1).strip()
@@ -153 +162 @@
                                 if 'embed' not in appInfo['video']:
                                         appInfo['video']=appInfo['video'].replace('watch?v=','embed/')
-                        #F***g appstream returns unknown for all the possible kinds
+                        #This appstream version returns unknown for all the possible kinds
 #                       if app.get_bundle_default():
 #                               appInfo['bundle']=app.get_bundle_default().get_kind()
-                        #Fix F***g appstream returns unknown for all the possible kinds
+                        #This appstream version returns unknown for all the possible kinds
                         #ID must contain bundle type as last field
                         for bundle in app.get_bundles():
                                 if bundle.get_kind()==0:
                                         kind=bundle.get_id().split('.')[-1]
-                                        appInfo['bundle']=kind.lower()
+                                        appInfo['bundle'].append(kind.lower())
                                         if kind.lower=='sh':
                                                 appInfo['installerUrl']=bundle.get_id()
@@ -192 +201 @@
                 'extraInfo':'',\
                 'size':'',\
-                'bundle':'',\
+                'bundle':[],\
                 'updatable':'',\
+                'component':'',\
+                'channel_releases':{}
                 }
                 return(appInfo)

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/loadStore.py

@@ -22 +22 @@
                 self.progress=0
                 self.error=0
-                self.zmd_store_dir='/var/lib/lliurexstore/zmds'
+#               self.zmd_store_dir='/var/lib/lliurexstore/zmds' #DEPRECATED
                 self.result={}
                 self.result['data']={}
@@ -71 +71 @@
                                 print ("Failed to load"+str(flag))
                                 pass
-                store=self.load_zmds_catalog(store)
+                #Zomandos are now available from appstream
+#               store=self.load_zmds_catalog(store)
                 store=self._sanitize_store(store)
                 self.store=store
@@ -77 +78 @@
         #def load_store
 
-        def load_zmds_catalog(self,store):
+        def load_zmds_catalog(self,store): #DEPRECATED
                 if os.path.exists(self.zmd_store_dir):
                         store=self._generic_file_load(self.zmd_store_dir,store)
@@ -142 +143 @@
                                         self._debug("Mergin app %s as is in LliureX"%app.get_id())
                                         lliurex_apps[app.get_id_filename()].subsume_full(app,appstream.AppSubsumeFlags.BOTH_WAYS)
-                                        store.remove_app(app)
+#                                       store.add_app(lliurex_apps[app.get_id_filename()])
                         #Remove apps whitout pkgname
                         if not app.get_pkgnames():

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/searchManager.py

@@ -7 +7 @@
         def __init__(self):
                 self.locale=locale.getlocale()[0]
-                self.dbg=False
+                self.dbg=True
                 self.store=''
                 self.plugin_actions={'search':'*','list':'*','list_sections':'*','info':'*'}
@@ -66 +66 @@
                         if (action=='search' or action=='info'):
                                 self._search_app(tokens,exact_match_for_search)
+                else:
+                        self._debug("Search needs a store")
                 self.progress=100
                 return(self.result)
@@ -83 +85 @@
                         app=self._app_exists(tokens[0])
                 if app:
-                        applist.append(app)
-                        self._debug("App direct match found: "+app.get_id())
+                        if type(app)==type([]):
+                                applist.extend(app)
+                        else:
+                                applist.append(app)
+#                       self._debug("App direct match found: "+app.get_id())
                 if not exact_match:
                         applist.extend(self._get_apps_by_match(tokens,applist))
@@ -171 +176 @@
         def _app_exists(self,app_name):
                 self._debug("Trying direct match for "+app_name)
+                #id_matches defines how to search for an app
+                # %s -> app_name; zero-lliurex-%s -> app_name with zero-lliurex- prefix and so on...
+                id_matches=['%s','zero-lliurex-%s','%s.desktop']
                 app=None
+                for id_string in id_matches:
+                                #                       app=self.store.get_app_by_id_ignore_prefix(id_string%app_name)
+                        app=self.store.get_apps_by_id(id_string%app_name)
+                        if app:
+                                break
+
+
                 #1.- Try exact match
-                app=self.store.get_app_by_id(app_name)
-                if not app:
-                #2.- Try exact match with zero-lliurex- for the zomandos
-                        app=self.store.get_app_by_id("zero-lliurex-"+app_name)
-                if not app:
-                #3.- Try exact match with .desktop
-                        app=self.store.get_app_by_id(app_name+".desktop")
+#               app=self.store.get_apps_by_id(app_name)
+#               if not app:
+#               #2.- Try exact match with zero-lliurex- for the zomandos
+#                       app=self.store.get_app_by_id("zero-lliurex-"+app_name)
+#               if not app:
+#               #3.- Try exact match with .desktop
+#                       app=self.store.get_apps_by_id(app_name+".desktop")
                 if not app:
                 #4.- Try exact match by pkgname
                         app=self.store.get_app_by_pkgname(app_name)
+#               if not app:
+#                       app=self.store.get_app_by_id_ignore_prefix(app_name)
                 self._debug("App found %s"%app)
                 return(app)
 
         def _get_apps_by_match(self,tokens,applist=[]):
-                #Add items witch match >= self.precision
+                #Add items with match >= self.precision
                 self._debug("Searching app by fuzzy match")
                 if not applist:

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/snapManager.py

@@ -10 +10 @@
 from gi.repository import AppStreamGlib as appstream
 import time
+import html
 #Needed for async find method, perhaps only on xenial
 wrap=Gio.SimpleAsyncResult()
@@ -15 +16 @@
         
         def __init__(self):
-                self.dbg=False
+                self.dbg=True
                 self.progress=0
                 self.partial_progress=0
                 self.plugin_actions={'install':'snap','remove':'snap','pkginfo':'snap','load':'snap'}
                 self.cache_dir=os.getenv("HOME")+"/.cache/lliurex-store"
+                self.cache_xmls=self.cache_dir+'/xmls/snap'
+                self.cache_last_update=self.cache_xmls+'/.snap.lu'
                 self.icons_folder=self.cache_dir+"/icons"
                 self.images_folder=self.cache_dir+"/images"
@@ -73 +76 @@
                         self.result['data']=self.store
                 else:
+                        self._check_dirs()
                         self.snap_client=Snapd.Client()
                         self.snap_client.connect_sync(None)
@@ -108 +112 @@
         #def _callback
 
+        def _check_dirs(self):
+                if not os.path.isdir(self.cache_xmls):
+                        os.makedirs(self.cache_xmls)
+
         def _load_snap_store(self,store):
                 pkgs=[]
+                #Look if cache is up-to-date
+                if os.path.isfile(self.cache_last_update):
+                        epoch_time=time.time()
+                        fcache=open(self.cache_last_update,'r')
+                        fcache_update=fcache.read()
+                        if not fcache_update:
+                                fcache_update=0
+                        if int(epoch_time)-int(fcache_update)<86400:
+                                if not os.listdir(os.path.dirname(self.cache_xmls)):
+                                        self._debug("Loading snap from cache")
+                                        store=self._load_from_cache(store)
+                                        return store
+
+                fcache=open(self.cache_last_update,'w')
+                fcache.write(str(int(time.time())))
                 if self.cli_mode:
                         pkgs=self._search_snap("*")
@@ -116 +139 @@
                 self._set_status(1)
                 for pkg in pkgs:
-                        store.add_app(self._generate_appstream_app(pkg))
+                        app=self.store.get_app_by_pkgname(pkg.get_name())
+                        if not app:
+                                self._debug("Searching for %s"%pkg.get_name())
+                                app=self.store.get_app_by_id(pkg.get_name().lower()+".desktop")
+                        if app:
+                                bundle=appstream.Bundle()
+                                bundle.set_kind(bundle.kind_from_string('SNAP'))
+                                bundle.set_id(pkg.get_name()+'.snap')
+                                app.add_bundle(bundle)
+                                app.add_category("Snap")
+                                store.add_app(self._generate_appstream_app_from_snap(pkg))
+                        else:
+                                store.add_app(self._generate_appstream_app_from_snap(pkg))
                 return(store)
 
-        def _generate_appstream_app(self,pkg):
+        def _load_from_cache(self,store):
+                for target_file in os.listdir(self.cache_xmls):
+                        if target_file.endswith('.xml'):
+                                store_file=Gio.File.new_for_path(self.cache_xmls+'/'+target_file)
+                                self._debug("Adding file %s/%s"%(self.cache_xmls,target_file))
+                                try:
+                                        store.from_file(store_file,None,None)
+                                except Exception as e:
+                                        self._debug("Couldn't add file %s to store"%target_file)
+                                        self._debug("Reason: %s"%e)
+                return store    
+
+        def _generate_appstream_app_from_snap(self,pkg):
                 bundle=appstream.Bundle()
                 app=appstream.App()
                 icon=appstream.Icon()
                 screenshot=appstream.Screenshot()
-                #F*****g appstream have kinds undefined but kind_from_string works... wtf?
 #               bundle.set_kind(appstream.BundleKind.SNAP)
                 bundle.set_kind(bundle.kind_from_string('SNAP'))
                 bundle.set_id(pkg.get_name()+'.snap')
                 app.add_bundle(bundle)
-                app.set_name("C",pkg.get_name())
+                app.set_name("C",pkg.get_name()+'.snap')
                 app.add_pkgname(pkg.get_name()+'.snap')
                 app.add_category("Snap")
@@ -135 +181 @@
                 release.set_version(pkg.get_version())
                 app.add_release(release)
-                sw_id=False
-                for snap_app in pkg.get_apps():
-                        if snap_app.get_desktop_file():
-                                app.set_id("%s"%snap_app.get_desktop_file())
-                                sw_id=True
-                                break
-                if sw_id==False:
-                        app.set_id("%s_%s.desktop"%(pkg.get_name(),pkg.get_name()))
-#               app.set_id(pkg.get_name()+'.snap')
+                app.set_id("io.snapcraft.%s"%pkg.get_name()+'.snap')
                 app.set_id_kind=appstream.IdKind.DESKTOP
-                description=("This is an Snap bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully."%pkg.get_name())
-                app.set_description("C",description+'<br>'+pkg.get_description())
-                app.set_comment("C",pkg.get_summary())
+                app.set_metadata_license("CC0-1.0")
+                description="This is an Snap bundle. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully."
+                pkg_description=pkg.get_description()
+                pkg_description=html.escape(pkg_description,quote=True)
+                pkg_description=pkg_description.replace("<","&gt;")
+                app.set_description("C","<p>%s</p><p>%s</p>"%(description,pkg_description))
+                app.set_comment("C",pkg.get_summary().rstrip('.'))
+
                 app.add_keyword("C",pkg.get_name())
                 for word in pkg.get_summary().split(' '):
-                        app.add_keyword("C",word)
+                        if len(word)>3:
+                                app.add_keyword("C",word)
 
                 if pkg.get_icon():
@@ -159 +203 @@
                                 icon.set_kind(appstream.IconKind.REMOTE)
                                 icon.set_name(pkg.get_icon())
+                                icon.set_url(pkg.get_icon())
                         app.add_icon(icon)
 
@@ -167 +212 @@
                         for snap_screen in pkg.get_screenshots():
                                 img=appstream.Image()
-#                               img.load_filename(self._download_file(snap_screen.get_url(),pkg.get_name(),self.images_folder))
                                 img.set_kind(appstream.ImageKind.SOURCE)
                                 img.set_url(snap_screen.get_url())
@@ -173 +217 @@
                         screenshot.add_image(img)
                         app.add_screenshot(screenshot)
+
+                if not os.path.isfile(self.cache_xmls+'/'+app.get_id_filename()):
+                        xml_path='%s/%s.xml'%(self.cache_xmls,app.get_id_filename())
+                        gioFile=Gio.File.new_for_path(xml_path)
+                        app.to_file(gioFile)
+                        #Fix some things in app_file...
+                        xml_file=open(xml_path,'r')
+                        xml_data=xml_file.readlines()
+                        xml_file.close()
+                        count=0
+                        xml_data[0]=xml_data[0]+"<components>\n"
+                        xml_data[-1]=xml_data[-1]+"\n"+"</components>"
+                        xml_file=open(xml_path,'w')
+                        xml_file.writelines(xml_data)
+                        xml_file.close()
                 return(app)
 
@@ -189 +248 @@
                 while 'Snapd' not in str(type(wrap)):
                         time.sleep(0.1)
+#               snaps,curr=self.snap_client.find_finish(wrap)
                 snaps=self.snap_client.find_finish(wrap)
                 if type(snaps)!=type([]):
@@ -205 +265 @@
                 pkgs=None
                 try:
-                        pkgs=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None,None)
+                                #                       pkgs,curr=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None)
+                        pkgs=self.snap_client.find_sync(Snapd.FindFlags.MATCH_NAME,tokens,None)
                 except Exception as e:
-                        print(e)
+                        print("ERR: %s"%e)
                         self._set_status(1)
                 stable_pkgs=[]
@@ -241 +302 @@
                                         self._debug("Unable to download %s"%url)
                                         self._debug("Reason: %s"%e)
+                                        target_file=''
 #                               os._exit(0)
                 return(target_file)
@@ -252 +314 @@
                 pkg=None
                 try:
-                        pkg=self.snap_client.list_one_sync(app_info['name'])
+                        pkg=self.snap_client.list_one_sync(app_info['package'].replace('.snap',''))
                         app_info['state']='installed'
                         pkgs=[pkg]
@@ -258 +320 @@
                         app_info['state']='available'
                         if self.cli_mode:
-                                pkgs=self._search_snap(app_info['name'])
-                        else:
-                                pkgs=self._search_snap_async(app_info['name'])
+                                pkgs=self._search_snap(app_info['package'].replace('.snap',''))
+                        else:
+                                pkgs=self._search_snap_async(app_info['package'].replace('.snap',''))
                         self._debug("Getting extended info for %s %s"%(app_info['name'],pkgs))
                 if type(pkgs)==type([]):
@@ -283 +345 @@
                 else:
                         try:
-                                self.snap_client.install_sync(app_info['name'],
+                                self.snap_client.install_sync(app_info['name'].replace('.snap',''),
                         None, # channel
                         self._callback, (None,),
@@ -302 +364 @@
                 else:
                         try:
-                                self.snap_client.remove_sync(app_info['name'],
+                                self.snap_client.remove_sync(app_info['name'].replace('.snap',''),
                        self._callback, (None,),
                                                 None) # cancellable

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/zmdManager.py

@@ -20 +20 @@
                 if hasattr(sys,'last_value') or not (os.path.exists(self.zmd_folder)):
                         #If there's an error at this point it only could be an importError caused by xmlrpc 
+                        print("ERROR!!!!")
                         self.disabled=True
                 self.plugin_actions={'install':'zmd','pkginfo':'zmd','remove':'zmd'}
@@ -66 +67 @@
                         except:
                                 self.disabled=True
+                                print("ERROR2!!!!")
                                 self._set_status(10)
                 self.progress=100

lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py

@@ -17 +17 @@
 class StoreManager():
         def __init__(self,*args,**kwargs):
-                self.dbg=False
                 if 'dbg' in kwargs.keys():
                         self.dbg=kwargs['dbg']
+                self.dbg=True
                 self._propagate_dbg=False
                 self.store=None
+                self.stores={}
                 self.related_actions={
                                         'load':['load'],
@@ -79 +80 @@
                                                         continue
                                                 if target_class.disabled==None:
-                                                        self._debug("Plugin %s will manage its state"%plugin_name)
-                                                #Time to check if plugin is disabled or enabled by parm
-                                                #Values for the plugins_registered dict must be the same as the parm name that enables the plugin
+                                                        self._debug("Plugin %s will set its status"%plugin_name)
                                                 else:
+                                                        #Time to check if plugin is disabled or enabled by parm
+                                                        #Values for the plugins_registered dict must be the same as the parm name that enables the plugin
                                                         for key,value in class_actions.items():
                                                                 val=value
@@ -264 +265 @@
                 self._debug("Joining action: %s"%action)
                 try:
+                        print("T: %s"%self.running_threads[action])
                         self.running_threads[action].join()
                 except Exception as e:
@@ -394 +396 @@
         def _load_Store(self):
                 action='load'
+                #Load appstream metada first
+                package_type='*'
+                load_function=self._execute_class_method(action,package_type,launchedby=None)
+                self.store=load_function.execute_action(action=action,store=self.store)['data']
+                #Once appstream is loaded load the appstream plugins for other package types (snap, appimage...)
                 for package_type in self.plugins_registered[action]:
-                        load_function=self._execute_class_method(action,package_type,launchedby=None)
-                        self.store=load_function.execute_action(action=action,store=self.store)['data']
+                        if package_type!='*':
+                                load_function=self._execute_class_method(action,package_type,launchedby=None)
+                                self.store=load_function.execute_action(action=action,store=self.store)['data']
         #def _load_Store
 
@@ -420 +428 @@
         #  - Dict with the related info
         ####
-        def _get_Extended_App_Info(self,info_applist,launchedby=None,fullsearch=True):
+        def _get_Extended_App_Info(self,info_applist,launchedby=None,fullsearch=True,channel=''):
                 #Check if there's any plugin for the distinct type of packages
                 action='pkginfo'
@@ -427 +435 @@
                 result['data']=[]
                 result['status']={'status':0,'msg':''}
+                processed=[]
                 for app_info in info_applist:
-                        package_type=self._check_package_type(app_info)
-                        if package_type in types_dict:
-                                types_dict[package_type].append(app_info)
+                        if channel:
+                                types_dict[channel]=[app_info]
                         else:
-                                types_dict[package_type]=[app_info]
+                                available_channels=self._check_package_type(app_info)
+                                for package_type in available_channels:
+                                        if app_info['component']!='':
+                                                if app_info['id'] in processed:
+                                                        self._debug("App %s processed"%app_info['id'])
+                                                        continue
+
+                                        if package_type in types_dict:
+                                                types_dict[package_type].append(app_info)
+                                        else:
+                                                types_dict[package_type]=[app_info]
+                                        processed.append(app_info['id'])
                 for package_type in types_dict:
                         self._debug("Checking plugin for %s %s"%(action,package_type))
                         if package_type in self.plugins_registered[action]:
-                                #Only search full info if it's required
+                                #Only seach full info if it's required
                                 if (fullsearch==False and package_type=='deb'):
                                         result['data'].extend(types_dict[package_type])
@@ -476 +495 @@
         def _search_Store(self,*args,**kwargs):
                 search_item=args[0]
+                return_msg=False
                 action='search'
                 if 'action' in kwargs.keys():
@@ -500 +520 @@
                 if (launchedby=='search'):
                                 exact_match=False
+                target_channel=''
+                if '=' in search_item:
+                        target_channel=search_item.split('=')[-1]
+                        search_item=search_item.split('=')[0]
                 for package_type in self.plugins_registered[action]:
+                        self._debug("Searching package type %s"%package_type)
                         search_function=self._execute_class_method(action,'*',launchedby=launchedby)
                         result.update(search_function.execute_action(self.store,action,search_item,exact_match,max_results))
@@ -513 +538 @@
                         self._debug("Add result for %s"%subordinate_action)
                         self.result[subordinate_action]=result
-                        #2.- Get rest of metadata (slower)
-                        subordinate_action='pkginfo'
-                        result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch)
-                        if launchedby:
-                                realAction=launchedby
-                                self._debug("Assigned results of %s to %s"%(action,realAction))
-                        if (result['status']['status']==0) or (result['status']['status']==9):
-                                return_msg=True
-                                if fullsearch:
-                                        result['status']['status']=0
-                        else:
-                                return_msg=False
+                        if fullsearch:
+                                #2.- Get rest of metadata (slower)
+                                subordinate_action='pkginfo'
+                                self._debug("Target channel: %s"%target_channel)
+                                result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch,target_channel)
+                                if launchedby:
+                                        realAction=launchedby
+                                        self._debug("Assigned results of %s to %s"%(action,realAction))
+                                if (result['status']['status']==0) or (result['status']['status']==9):
+                                        return_msg=True
+                                        if fullsearch:
+                                                result['status']['status']=0
+                                else:
+                                        return_msg=False
                 else:
                         return_msg=False
@@ -563 +590 @@
                                         types_dict={}
                                         break
-                                
-                                package_type=self._check_package_type(app_info)
-                                if package_type in types_dict:
-                                        types_dict[package_type].append(app_info)
-                                else:
-                                        types_dict[package_type]=[app_info]
+                                processed=[]
+                                available_channels=self._check_package_type(app_info)
+                                for package_type in available_channels:
+                                        if app_info['component']!='':
+                                                if app_info['id'] in processed:
+                                                        self._debug("App %s processed"%app_info['id'])
+                                                        continue
+
+                                        if package_type in types_dict:
+                                                types_dict[package_type].append(app_info)
+                                        else:
+                                                types_dict[package_type]=[app_info]
+                                        processed.append(app_info['id'])
 
                         for package_type in types_dict:
@@ -591 +625 @@
                                         result=install_function.execute_action(action,types_dict[package_type])
                                         self.result[action]=result
-                                        if result['status']['status']==0:
+                                        #Deprecated. Earlier versions stored the "app" object so here the app could get marked as installed/removed without neeed of import or query anything
+                                        #Python>=3.6 don't let us to store the app object in a queue (needed for the GUI) so this code becames deprecated.
+#                                       if result['status']['status']==0:
                                                 #Mark the apps as installed or available
-                                                for app in types_dict[package_type]:
-                                                        if action=='install':
-                                                                app['appstream_id'].set_state(1)
-                                                                self._debug("App state changed to installed")
-                                                        else:
-                                                                app['appstream_id'].set_state(2)
-                                                                self._debug("App state changed to available")
+#                                               for app in types_dict[package_type]:
+#                                                       if action=='install':
+#                                                               app['appstream_id'].set_state(1)
+#                                                               self._debug("App state changed to installed")
+#                                                       else:
+#                                                               app['appstream_id'].set_state(2)
+#                                                               self._debug("App state changed to available")
                                         return_msg=True
                 self._log("Result %s: %s"%(action,self.result[action]))
@@ -616 +652 @@
                 #Zomandos must have the subcategory "Zomando"
                 self._debug("Checking package type for app "+app_info['name'])
-                if "Zomando" in app_info['categories']:
-                        return_msg="zmd"
-                else:
+                return_msg=[]
+                if app_info['bundle']:
+                        return_msg.extend(app_info['bundle'])
+                else:
+                        if "Zomando" in app_info['categories']:
+                                return_msg.append("zmd")
+                        if 'component' in app_info.keys():
+                                if app_info['component']!='':
+                                        return_msg.append('deb')
                 #Standalone installers must have an installerUrl field loaded from a bundle type=script description
-                        if app_info['bundle']!='':
-                                return_msg=app_info['bundle']
-                        elif app_info['installerUrl']!='':
-                                return_msg="sh"
-                        else:
-                                return_msg="deb"
+                        if app_info['installerUrl']!='':
+                                return_msg.append("sh")
                 return(return_msg)
         #def _check_package_type