209 lines
7.2 KiB
Python
Executable File
209 lines
7.2 KiB
Python
Executable File
# -*- coding: utf-8 -*-
|
|
# --------------------------------------------------------------------------------
|
|
# Updater process
|
|
# --------------------------------------------------------------------------------
|
|
|
|
import os
|
|
import time
|
|
|
|
import scrapertools
|
|
import versiontools
|
|
from platformcode import config, logger
|
|
|
|
|
|
# Método antiguo, muestra un popup con la versión
|
|
def checkforupdates():
|
|
logger.info()
|
|
|
|
# Valores por defecto
|
|
numero_version_publicada = 0
|
|
tag_version_publicada = ""
|
|
|
|
# Lee la versión remota
|
|
from core import api
|
|
latest_packages = api.plugins_get_latest_packages()
|
|
for latest_package in latest_packages["body"]:
|
|
if latest_package["package"] == "plugin":
|
|
numero_version_publicada = latest_package["version"]
|
|
tag_version_publicada = latest_package["tag"]
|
|
break
|
|
|
|
logger.info("version remota=" + str(numero_version_publicada))
|
|
|
|
# Lee la versión local
|
|
numero_version_local = versiontools.get_current_plugin_version()
|
|
logger.info("version local=" + str(numero_version_local))
|
|
|
|
hayqueactualizar = numero_version_publicada > numero_version_local
|
|
logger.info("-> hayqueactualizar=" + repr(hayqueactualizar))
|
|
|
|
# Si hay actualización disponible, devuelve la Nueva versión para que cada plataforma se encargue de mostrar los avisos
|
|
if hayqueactualizar:
|
|
return tag_version_publicada
|
|
else:
|
|
return None
|
|
|
|
|
|
# Método nuevo, devuelve el nº de actualizaciones disponibles además de indicar si hay nueva versión del plugin
|
|
def get_available_updates():
|
|
logger.info()
|
|
|
|
# Cuantas actualizaciones hay?
|
|
number_of_updates = 0
|
|
new_published_version_tag = ""
|
|
|
|
# Lee la versión remota
|
|
from core import api
|
|
latest_packages = api.plugins_get_latest_packages()
|
|
|
|
for latest_package in latest_packages["body"]:
|
|
|
|
if latest_package["package"] == "plugin":
|
|
if latest_package["version"] > versiontools.get_current_plugin_version():
|
|
number_of_updates = number_of_updates + 1
|
|
new_published_version_tag = latest_package["tag"]
|
|
|
|
elif latest_package["package"] == "channels":
|
|
if latest_package["version"] > versiontools.get_current_channels_version():
|
|
number_of_updates = number_of_updates + 1
|
|
|
|
elif latest_package["package"] == "servers":
|
|
if latest_package["version"] > versiontools.get_current_servers_version():
|
|
number_of_updates = number_of_updates + 1
|
|
|
|
return new_published_version_tag, number_of_updates
|
|
|
|
|
|
def update(item):
|
|
logger.info()
|
|
|
|
# Valores por defecto
|
|
published_version_url = ""
|
|
published_version_filename = ""
|
|
|
|
# Lee la versión remota
|
|
from core import api
|
|
latest_packages = api.plugins_get_latest_packages()
|
|
for latest_package in latest_packages["body"]:
|
|
if latest_package["package"] == "plugin":
|
|
published_version_url = latest_package["url"]
|
|
published_version_filename = latest_package["filename"]
|
|
published_version_number = latest_package["version"]
|
|
break
|
|
|
|
# La URL viene del API, y lo descarga en "userdata"
|
|
remotefilename = published_version_url
|
|
localfilename = os.path.join(config.get_data_path(), published_version_filename)
|
|
|
|
download_and_install(remotefilename, localfilename)
|
|
|
|
|
|
def download_and_install(remote_file_name, local_file_name):
|
|
logger.info("from " + remote_file_name + " to " + local_file_name)
|
|
|
|
if os.path.exists(local_file_name):
|
|
os.remove(local_file_name)
|
|
|
|
# Descarga el fichero
|
|
inicio = time.clock()
|
|
from core import downloadtools
|
|
downloadtools.downloadfile(remote_file_name, local_file_name, continuar=False)
|
|
fin = time.clock()
|
|
logger.info("Descargado en %d segundos " % (fin - inicio + 1))
|
|
|
|
logger.info("descomprime fichero...")
|
|
import ziptools
|
|
unzipper = ziptools.ziptools()
|
|
|
|
# Lo descomprime en "addons" (un nivel por encima del plugin)
|
|
installation_target = os.path.join(config.get_runtime_path(), "..")
|
|
logger.info("installation_target=%s" % installation_target)
|
|
|
|
unzipper.extract(local_file_name, installation_target)
|
|
|
|
# Borra el zip descargado
|
|
logger.info("borra fichero...")
|
|
os.remove(local_file_name)
|
|
logger.info("...fichero borrado")
|
|
|
|
|
|
def update_channel(channel_name):
|
|
logger.info(channel_name)
|
|
|
|
import channeltools
|
|
remote_channel_url, remote_version_url = channeltools.get_channel_remote_url(channel_name)
|
|
local_channel_path, local_version_path, local_compiled_path = channeltools.get_channel_local_path(channel_name)
|
|
|
|
# Version remota
|
|
try:
|
|
data = scrapertools.cachePage(remote_version_url)
|
|
logger.info("remote_data=" + data)
|
|
remote_version = int(scrapertools.find_single_match(data, '<version>([^<]+)</version>'))
|
|
addon_condition = int(scrapertools.find_single_match(data, "<addon_version>([^<]*)</addon_version>")
|
|
.replace(".", "").ljust(len(str(versiontools.get_current_plugin_version())), '0'))
|
|
except:
|
|
remote_version = 0
|
|
addon_condition = 0
|
|
|
|
logger.info("remote_version=%d" % remote_version)
|
|
|
|
# Version local
|
|
if os.path.exists(local_version_path):
|
|
infile = open(local_version_path)
|
|
from core import jsontools
|
|
data = jsontools.load(infile.read())
|
|
infile.close()
|
|
|
|
local_version = data.get('version', 0)
|
|
else:
|
|
local_version = 0
|
|
|
|
logger.info("local_version=%d" % local_version)
|
|
|
|
# Comprueba si ha cambiado
|
|
updated = (remote_version > local_version) and (versiontools.get_current_plugin_version() >= addon_condition)
|
|
|
|
if updated:
|
|
logger.info("downloading...")
|
|
download_channel(channel_name)
|
|
|
|
return updated
|
|
|
|
|
|
def download_channel(channel_name):
|
|
logger.info(channel_name)
|
|
|
|
import channeltools
|
|
remote_channel_url, remote_version_url = channeltools.get_channel_remote_url(channel_name)
|
|
local_channel_path, local_version_path, local_compiled_path = channeltools.get_channel_local_path(channel_name)
|
|
|
|
# Descarga el canal
|
|
try:
|
|
updated_channel_data = scrapertools.cachePage(remote_channel_url)
|
|
outfile = open(local_channel_path, "wb")
|
|
outfile.write(updated_channel_data)
|
|
outfile.flush()
|
|
outfile.close()
|
|
logger.info("Grabado a " + local_channel_path)
|
|
except:
|
|
import traceback
|
|
logger.error(traceback.format_exc())
|
|
|
|
# Descarga la version (puede no estar)
|
|
try:
|
|
updated_version_data = scrapertools.cachePage(remote_version_url)
|
|
outfile = open(local_version_path, "w")
|
|
outfile.write(updated_version_data)
|
|
outfile.flush()
|
|
outfile.close()
|
|
logger.info("Grabado a " + local_version_path)
|
|
except:
|
|
import traceback
|
|
logger.error(traceback.format_exc())
|
|
|
|
if os.path.exists(local_compiled_path):
|
|
os.remove(local_compiled_path)
|
|
|
|
from platformcode import platformtools
|
|
platformtools.dialog_notification(channel_name + " actualizado", "Se ha descargado una nueva versión")
|