# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
"""
See documentation for usage
https://github.com/CGCookie/blender-addon-updater
"""
import urllib.request
import urllib
import os
import json
import zipfile
import shutil
import asyncio # for async processing
import threading
import time
from datetime import datetime,timedelta
# blender imports, used in limited cases
import bpy
import addon_utils
# -----------------------------------------------------------------------------
# Define error messages/notices & hard coded globals
# -----------------------------------------------------------------------------
DEFAULT_API_URL = "https://api.github.com" # plausibly could be some other system
DEFAULT_TIMEOUT = 10
DEFAULT_PER_PAGE = 30
# -----------------------------------------------------------------------------
# The main class
# -----------------------------------------------------------------------------
class Singleton_updater(object):
"""
This is the singleton class to reference a copy from,
it is the shared module level class
"""
def __init__(self):
"""
#UPDATE
:param user: string # name of the user owning the repository
:param repo: string # name of the repository
:param api_url: string # should just be the github api link
:param timeout: integer # request timeout
:param current_version: tuple # typically 3 values meaning the version #
"""
self._user = None
self._repo = None
self._website = None
self._api_url = DEFAULT_API_URL
self._current_version = None
self._tags = []
self._tag_latest = None
self._tag_names = []
self._latest_release = None
self._include_branches = False
self._include_branch_list = ['master']
self._include_branch_autocheck = False
self._manual_only = False
self._version_min_update = None
self._version_max_update = None
# by default, backup current addon if new is being loaded
self._backup_current = True
# by default, enable/disable the addon.. but less safe.
self._auto_reload_post_update = False
self._check_interval_enable = False
self._check_interval_months = 0
self._check_interval_days = 7
self._check_interval_hours = 0
self._check_interval_minutes = 0
# runtime variables, initial conditions
self._verbose = False
self._fake_install = False
self._async_checking = False # only true when async daemon started
self._update_ready = None
self._update_link = None
self._update_version = None
self._source_zip = None
self._check_thread = None
self._skip_tag = None
# get from module data
self._addon = __package__.lower()
self._addon_package = __package__ # must not change
self._updater_path = os.path.join(os.path.dirname(__file__),
self._addon+"_updater")
self._addon_root = os.path.dirname(__file__)
self._json = {}
self._error = None
self._error_msg = None
self._prefiltered_tag_count = 0
# to verify a valid import, in place of placeholder import
self.invalidupdater = False
# -------------------------------------------------------------------------
# Getters and setters
# -------------------------------------------------------------------------
@property
def addon(self):
return self._addon
@addon.setter
def addon(self, value):
self._addon = str(value)
@property
def verbose(self):
return self._verbose
@verbose.setter
def verbose(self, value):
try:
self._verbose = bool(value)
if self._verbose == True:
print(self._addon+" updater verbose is enabled")
except:
raise ValueError("Verbose must be a boolean value")
@property
def include_branches(self):
return self._include_branches
@include_branches.setter
def include_branches(self, value):
try:
self._include_branches = bool(value)
except:
raise ValueError("include_branches must be a boolean value")
@property
def include_branch_list(self):
return self._include_branch_list
@include_branch_list.setter
def include_branch_list(self, value):
try:
if value is None:
self._include_branch_list = ['master']
elif type(value) != type(['master']):
raise ValueError("include_branch_list should be a list of valid branches")
else:
self._include_branch_list = value
except:
raise ValueError("include_branch_list should be a list of valid branches")
# not currently used
@property
def include_branch_autocheck(self):
return self._include_branch_autocheck
@include_branch_autocheck.setter
def include_branch_autocheck(self, value):
try:
self._include_branch_autocheck = bool(value)
except:
raise ValueError("include_branch_autocheck must be a boolean value")
@property
def manual_only(self):
return self._manual_only
@manual_only.setter
def manual_only(self, value):
try:
self._manual_only = bool(value)
except:
raise ValueError("manual_only must be a boolean value")
@property
def auto_reload_post_update(self):
return self._auto_reload_post_update
@auto_reload_post_update.setter
def auto_reload_post_update(self, value):
try:
self._auto_reload_post_update = bool(value)
except:
raise ValueError("Must be a boolean value")
@property
def fake_install(self):
return self._fake_install
@fake_install.setter
def fake_install(self, value):
if type(value) != type(False):
raise ValueError("fake_install must be a boolean value")
self._fake_install = bool(value)
@property
def user(self):
return self._user
@user.setter
def user(self, value):
try:
self._user = str(value)
except:
raise ValueError("User must be a string value")
@property
def json(self):
if self._json == {}:
self.set_updater_json()
return self._json
@property
def repo(self):
return self._repo
@repo.setter
def repo(self, value):
try:
self._repo = str(value)
except:
raise ValueError("User must be a string")
@property
def website(self):
return self._website
@website.setter
def website(self, value):
if self.check_is_url(value) == False:
raise ValueError("Not a valid URL: " + value)
self._website = value
@property
def async_checking(self):
return self._async_checking
@property
def api_url(self):
return self._api_url
@api_url.setter
def api_url(self, value):
if self.check_is_url(value) == False:
raise ValueError("Not a valid URL: " + value)
self._api_url = value
@property
def stage_path(self):
return self._updater_path
@stage_path.setter
def stage_path(self, value):
if value is None:
if self._verbose:print("Aborting assigning stage_path, it's null")
return
elif value is not None and not os.path.exists(value):
try:
os.makedirs(value)
except:
if self._verbose:print("Error trying to staging path")
return
self._updater_path = value
@property
def tags(self):
if self._tags == []:
return []
tag_names = []
for tag in self._tags:
tag_names.append(tag["name"])
return tag_names
@property
def tag_latest(self):
if self._tag_latest is None:
return None
return self._tag_latest["name"]
@property
def latest_release(self):
if self._releases_latest is None:
return None
return self._latest_release
@property
def current_version(self):
return self._current_version
@property
def update_ready(self):
return self._update_ready
@property
def update_version(self):
return self._update_version
@property
def update_link(self):
return self._update_link
@current_version.setter
def current_version(self,tuple_values):
if type(tuple_values) is not tuple:
raise ValueError(\
"Not a tuple! current_version must be a tuple of integers")
for i in tuple_values:
if type(i) is not int:
raise ValueError(\
"Not an integer! current_version must be a tuple of integers")
self._current_version = tuple_values
def set_check_interval(self,enable=False,months=0,days=14,hours=0,minutes=0):
# enabled = False, default initially will not check against frequency
# if enabled, default is then 2 weeks
if type(enable) is not bool:
raise ValueError("Enable must be a boolean value")
if type(months) is not int:
raise ValueError("Months must be an integer value")
if type(days) is not int:
raise ValueError("Days must be an integer value")
if type(hours) is not int:
raise ValueError("Hours must be an integer value")
if type(minutes) is not int:
raise ValueError("Minutes must be an integer value")
if enable==False:
self._check_interval_enable = False
else:
self._check_interval_enable = True
self._check_interval_months = months
self._check_interval_days = days
self._check_interval_hours = hours
self._check_interval_minutes = minutes
@property
def check_interval(self):
return (self._check_interval_enable,
self._check_interval_months,
self._check_interval_days,
self._check_interval_hours,
self._check_interval_minutes)
@property
def error(self):
return self._error
@property
def error_msg(self):
return self._error_msg
@property
def version_min_update(self):
return self._version_min_update
@version_min_update.setter
def version_min_update(self, value):
if value is None:
self._version_min_update = None
return
if type(value) != type((1,2,3)):
raise ValueError("Version minimum must be a tuple")
else:
# potentially check entries are integers
self._version_min_update = value
@property
def version_max_update(self):
return self._version_max_update
@version_max_update.setter
def version_max_update(self, value):
if value is None:
self._version_max_update = None
return
if type(value) != type((1,2,3)):
raise ValueError("Version maximum must be a tuple")
else:
# potentially check entries are integers
self._version_max_update = value
# -------------------------------------------------------------------------
# Parameter validation related functions
# -------------------------------------------------------------------------
def check_is_url(self,url):
if not ("http://" in url or "https://" in url):
return False
if "." not in url:
return False
return True
def get_tag_names(self):
tag_names = []
self.get_tags(self)
for tag in self._tags:
tag_names.append(tag["name"])
return tag_names
# declare how the class gets printed
def __repr__(self):
return "<Module updater from {a}>".format(a=__file__)
def __str__(self):
return "Updater, with user: {a}, repository: {b}, url: {c}".format(
a=self._user,
b=self._repo, c=self.form_repo_url())
# -------------------------------------------------------------------------
# API-related functions
# -------------------------------------------------------------------------
def form_repo_url(self):
return self._api_url+"/repos/"+self.user+"/"+self.repo
def get_tags(self):
request = "/repos/"+self.user+"/"+self.repo+"/tags"
if self.verbose:print("Getting tags from server")
# get all tags, internet call
all_tags = self.get_api(request)
self._prefiltered_tag_count = len(all_tags)
# pre-process to skip tags
if self.skip_tag is not None:
self._tags = [tg for tg in all_tags if self.skip_tag(tg)==False]
else:
self._tags = all_tags
# get additional branches too, if needed, and place in front
# does NO checking here whether branch is valid
if self._include_branches == True:
temp_branches = self._include_branch_list.copy()
temp_branches.reverse()
for branch in temp_branches:
request = self._api_url +"/repos/" \
+self.user+"/"+self.repo+"/zipball/"+branch
include = {
"name":branch.title(),
"zipball_url":request
}
self._tags = [include] + self._tags # append to front
if self._tags is None:
# some error occurred
self._tag_latest = None
self._tags = []
return
elif self._prefiltered_tag_count == 0 and self._include_branches == False:
self._tag_latest = None
self._error = "No releases found"
self._error_msg = "No releases or tags found on this repository"
if self.verbose:print("No releases or tags found on this repository")
elif self._prefiltered_tag_count == 0 and self._include_branches == True:
self._tag_latest = self._tags[0]
if self.verbose:
branch = self._include_branch_list[0]
print("{} branch found, no releases".format(branch),self._tags[0])
elif len(self._tags) == 0 and self._prefiltered_tag_count > 0:
self._tag_latest = None
self._error = "No releases available"
self._error_msg = "No versions found within compatible version range"
if self.verbose:print("No versions found within compatible version range")
else:
if self._include_branches == False:
self._tag_latest = self._tags[0]
if self.verbose:print("Most recent tag found:",self._tags[0])
else:
# don't return branch if in list
n = len(self._include_branch_list)
self._tag_latest = self._tags[n] # guarenteed at least len()=n+1
if self.verbose:print("Most recent tag found:",self._tags[n])
# all API calls to base url
def get_api_raw(self, url):
request = urllib.request.Request(self._api_url + url)
try:
result = urllib.request.urlopen(request)
except urllib.error.HTTPError as e:
self._error = "HTTP error"
self._error_msg = str(e.code)
self._update_ready = None
except urllib.error.URLError as e:
self._error = "URL error, check internet connection"
self._error_msg = str(e.reason)
self._update_ready = None
return None
else:
result_string = result.read()
result.close()
return result_string.decode()
# if we didn't get here, return or raise something else
# result of all api calls, decoded into json format
def get_api(self, url):
# return the json version
get = None
get = self.get_api_raw(url) # this can fail by self-created error raising
if get is not None:
return json.JSONDecoder().decode( get )
else:
return None
# create a working directory and download the new files
def stage_repository(self, url):
# first make/clear the staging folder
# ensure the folder is always "clean"
local = os.path.join(self._updater_path,"update_staging")
error = None
if self._verbose:print("Preparing staging folder for download:\n",local)
if os.path.isdir(local) == True:
try:
shutil.rmtree(local)
os.makedirs(local)
except:
error = "failed to remove existing staging directory"
else:
try:
os.makedirs(local)
except:
error = "failed to make staging directory"
if error is not None:
if self._verbose: print("Error: Aborting update, "+error)
raise ValueError("Aborting update, "+error)
if self._backup_current==True:
self.create_backup()
if self._verbose:print("Now retrieving the new source zip")
self._source_zip = os.path.join(local,"source.zip")
if self._verbose:print("Starting download update zip")
try:
urllib.request.urlretrieve(url, self._source_zip)
except Exception as e:
self._error = "Error retreiving download, bad link?"
self._error_msg = "Error: {}".format(e)
if self._verbose:
print("Error retreiving download, bad link?")
print("Error: {}".format(e))
return
if self._verbose:print("Successfully downloaded update zip")
def create_backup(self):
if self._verbose:print("Backing up current addon folder")
local = os.path.join(self._updater_path,"backup")
tempdest = os.path.join(self._addon_root,
os.pardir,
self._addon+"_updater_backup_temp")
if os.path.isdir(local) == True:
shutil.rmtree(local)
if self._verbose:print("Backup destination path: ",local)
# make the copy
shutil.copytree(self._addon_root,tempdest)
shutil.move(tempdest,local)
# save the date for future ref
now = datetime.now()
self._json["backup_date"] = "{m}-{d}-{yr}".format(
m=now.strftime("%B"),d=now.day,yr=now.year)
self.save_updater_json()
def restore_backup(self):
if self._verbose:print("Restoring backup")
if self._verbose:print("Backing up current addon folder")
backuploc = os.path.join(self._updater_path,"backup")
tempdest = os.path.join(self._addon_root,
os.pardir,
self._addon+"_updater_backup_temp")
tempdest = os.path.abspath(tempdest)
# make the copy
shutil.move(backuploc,tempdest)
shutil.rmtree(self._addon_root)
os.rename(tempdest,self._addon_root)
self._json["backup_date"] = ""
self._json["just_restored"] = True
self._json["just_updated"] = True
self.save_updater_json()
self.reload_addon()
def upack_staged_zip(self):
if os.path.isfile(self._source_zip) == False:
if self._verbose:print("Error, update zip not found")
return -1
# clear the existing source folder in case previous files remain
try:
shutil.rmtree( os.path.join(self._updater_path,"source") )
os.makedirs( os.path.join(self._updater_path,"source") )
if self._verbose:print("Source folder cleared and recreated")
except:
pass
if self.verbose:print("Begin extracting source")
if zipfile.is_zipfile(self._source_zip):
with zipfile.ZipFile(self._source_zip) as zf:
# extractall is no longer a security hazard
zf.extractall(os.path.join(self._updater_path,"source"))
else:
if self._verbose:
print("Not a zip file, future add support for just .py files")
raise ValueError("Resulting file is not a zip")
if self.verbose:print("Extracted source")
# either directly in root of zip, or one folder level deep
unpath = os.path.join(self._updater_path,"source")
if os.path.isfile(os.path.join(unpath,"__init__.py")) == False:
dirlist = os.listdir(unpath)
if len(dirlist)>0:
unpath = os.path.join(unpath,dirlist[0])
if os.path.isfile(os.path.join(unpath,"__init__.py")) == False:
if self._verbose:
print("not a valid addon found")
print("Paths:")
print(dirlist)
raise ValueError("__init__ file not found in new source")
# now commence merging in the two locations:
origpath = os.path.dirname(__file__) # verify, is __file__ always valid?
self.deepMergeDirectory(origpath,unpath)
# now save the json state
# Change to True, to trigger the handler on other side
# if allowing reloading within same blender instance
self._json["just_updated"] = True
self.save_updater_json()
self.reload_addon()
self._update_ready = False
# merge folder 'merger' into folder 'base' without deleting existing
def deepMergeDirectory(self,base,merger):
if not os.path.exists(base):
if self._verbose:print("Base path does not exist")
return -1
elif not os.path.exists(merger):
if self._verbose:print("Merger path does not exist")
return -1
# this should have better error handling
# and also avoid the addon dir
# Could also do error handling outside this function
for path, dirs, files in os.walk(merger):
relPath = os.path.relpath(path, merger)
destPath = os.path.join(base, relPath)
if not os.path.exists(destPath):
os.makedirs(destPath)
for file in files:
destFile = os.path.join(destPath, file)
if os.path.isfile(destFile):
os.remove(destFile)
srcFile = os.path.join(path, file)
os.rename(srcFile, destFile)
def reload_addon(self):
# if post_update false, skip this function
# else, unload/reload addon & trigger popup
if self._auto_reload_post_update == False:
print("Restart blender to reload addon and complete update")
return
if self._verbose:print("Reloading addon...")
addon_utils.modules(refresh=True)
bpy.utils.refresh_script_paths()
# not allowed in restricted context, such as register module
# toggle to refresh
bpy.ops.wm.addon_disable(module=self._addon_package)
bpy.ops.wm.addon_refresh()
bpy.ops.wm.addon_enable(module=self._addon_package)
# -------------------------------------------------------------------------
# Other non-api functions and setups
# -------------------------------------------------------------------------
def clear_state(self):
self._update_ready = None
self._update_link = None
self._update_version = None
self._source_zip = None
self._error = None
self._error_msg = None
def version_tuple_from_text(self,text):
if text is None: return ()
# should go through string and remove all non-integers,
# and for any given break split into a different section
segments = []
tmp = ''
for l in str(text):
if l.isdigit()==False:
if len(tmp)>0:
segments.append(int(tmp))
tmp = ''
else:
tmp+=l
if len(tmp)>0:
segments.append(int(tmp))
if len(segments)==0:
if self._verbose:print("No version strings found text: ",text)
if self._include_branches == False:
return ()
else:
return (text)
return tuple(segments)
# called for running check in a background thread
def check_for_update_async(self, callback=None):
if self._json is not None and "update_ready" in self._json:
if self._json["update_ready"] == True:
self._update_ready = True
self._update_link = self._json["version_text"]["link"]
self._update_version = str(self._json["version_text"]["version"])
# cached update
callback(True)
return
# do the check
if self._check_interval_enable == False:
return
elif self._async_checking == True:
if self._verbose:print("Skipping async check, already started")
return # already running the bg thread
elif self._update_ready is None:
self.start_async_check_update(False, callback)
def check_for_update_now(self, callback=None):
self._error = None
self._error_msg = None
if self._verbose:
print("Check update pressed, first getting current status")
if self._async_checking == True:
if self._verbose:print("Skipping async check, already started")
return # already running the bg thread
elif self._update_ready is None:
self.start_async_check_update(True, callback)
else:
self._update_ready = None
self.start_async_check_update(True, callback)
# this function is not async, will always return in sequential fashion
# but should have a parent which calls it in another thread
def check_for_update(self, now=False):
if self._verbose:print("Checking for update function")
# clear the errors if any
self._error = None
self._error_msg = None
# avoid running again in, just return past result if found
# but if force now check, then still do it
if self._update_ready is not None and now == False:
return (self._update_ready,self._update_version,self._update_link)
if self._current_version is None:
raise ValueError("current_version not yet defined")
if self._repo is None:
raise ValueError("repo not yet defined")
if self._user is None:
raise ValueError("username not yet defined")
self.set_updater_json() # self._json
if now == False and self.past_interval_timestamp()==False:
if self.verbose:
print("Aborting check for updated, check interval not reached")
return (False, None, None)
# check if using tags or releases
# note that if called the first time, this will pull tags from online
if self._fake_install == True:
if self._verbose:
print("fake_install = True, setting fake version as ready")
self._update_ready = True
self._update_version = "(999,999,999)"
self._update_link = "http://127.0.0.1"
return (self._update_ready, self._update_version, self._update_link)
# primary internet call
self.get_tags() # sets self._tags and self._tag_latest
self._json["last_check"] = str(datetime.now())
self.save_updater_json()
# can be () or ('master') in addition to branchs, and version tag
new_version = self.version_tuple_from_text(self.tag_latest)
if len(self._tags)==0:
self._update_ready = False
self._update_version = None
self._update_link = None
return (False, None, None)
elif self._include_branches == False:
link = self._tags[0]["zipball_url"] # potentially other sources
else:
n = len(self._include_branch_list)
if len(self._tags)==n:
# effectively means no tags found on repo
# so provide the first one as default
link = self._tags[0]["zipball_url"] # potentially other sources
else:
link = self._tags[n]["zipball_url"] # potentially other sources
if new_version == ():
self._update_ready = False
self._update_version = None
self._update_link = None
return (False, None, None)
elif str(new_version).lower() in self._include_branch_list:
# handle situation where master/whichever branch is included
# however, this code effectively is not triggered now
# as new_version will only be tag names, not branch names
if self._include_branch_autocheck == False:
# don't offer update as ready,
# but set the link for the default
# branch for installing
self._update_ready = True
self._update_version = new_version
self._update_link = link
self.save_updater_json()
return (True, new_version, link)
else:
raise ValueError("include_branch_autocheck: NOT YET DEVELOPED")
# bypass releases and look at timestamp of last update
# from a branch compared to now, see if commit values
# match or not.
else:
# situation where branches not included
if new_version > self._current_version:
self._update_ready = True
self._update_version = new_version
self._update_link = link
self.save_updater_json()
return (True, new_version, link)
# elif new_version != self._current_version:
# self._update_ready = False
# self._update_version = new_version
# self._update_link = link
# self.save_updater_json()
# return (True, new_version, link)
# if no update, set ready to False from None
self._update_ready = False
self._update_version = None
self._update_link = None
return (False, None, None)
def set_tag(self,name):
tg = None
for tag in self._tags:
if name == tag["name"]:
tg = tag
break
if tg is None:
raise ValueError("Version tag not found: "+revert_tag)
new_version = self.version_tuple_from_text(self.tag_latest)
self._update_version = new_version
self._update_link = tg["zipball_url"]
def run_update(self,force=False,revert_tag=None,clean=False,callback=None):
# revert_tag: could e.g. get from drop down list
# different versions of the addon to revert back to
# clean: not used, but in future could use to totally refresh addon
self._json["update_ready"] = False
self._json["ignore"] = False # clear ignore flag
self._json["version_text"] = {}
if revert_tag is not None:
self.set_tag(revert_tag)
self._update_ready = True
# clear the errors if any
self._error = None
self._error_msg = None
if self.verbose:print("Running update")
if self._fake_install == True:
# change to True, to trigger the reload/"update installed" handler
if self._verbose:
print("fake_install=True")
print("Just reloading and running any handler triggers")
self._json["just_updated"] = True
self.save_updater_json()
if self._backup_current == True:
self.create_backup()
self.reload_addon()
self._update_ready = False
elif force==False:
if self._update_ready != True:
if self.verbose:print("Update stopped, new version not ready")
return 1 # stopped
elif self._update_link is None:
# this shouldn't happen if update is ready
if self.verbose:print("Update stopped, update link unavailable")
return 1 # stopped
if self.verbose and revert_tag is None:
print("Staging update")
elif self.verbose:
print("Staging install")
self.stage_repository(self._update_link)
self.upack_staged_zip()
else:
if self._update_link is None:
return # stopped, no link - run check update first or set tag
if self.verbose:print("Forcing update")
# first do a check
if self._update_link is None:
if self.verbose:print("Update stopped, could not get link")
return
self.stage_repository(self._update_link)
self.upack_staged_zip()
# would need to compare against other versions held in tags
# run the front-end's callback if provided
if callback is not None:callback()
# return something meaningful, 0 means it worked
return 0
def past_interval_timestamp(self):
if self._check_interval_enable == False:
return True # ie this exact feature is disabled
if "last_check" not in self._json or self._json["last_check"] == "":
return True
else:
now = datetime.now()
last_check = datetime.strptime(self._json["last_check"],
"%Y-%m-%d %H:%M:%S.%f")
next_check = last_check
offset = timedelta(
days=self._check_interval_days + 30*self._check_interval_months,
hours=self._check_interval_hours,
minutes=self._check_interval_minutes
)
delta = (now - offset) - last_check
if delta.total_seconds() > 0:
if self._verbose:
print("{} Updater: Time to check for updates!".format(self._addon))
return True
else:
if self._verbose:
print("{} Updater: Determined it's not yet time to check for updates".format(self._addon))
return False
def set_updater_json(self):
if self._updater_path is None:
raise ValueError("updater_path is not defined")
elif os.path.isdir(self._updater_path) == False:
os.makedirs(self._updater_path)
jpath = os.path.join(self._updater_path,"updater_status.json")
if os.path.isfile(jpath):
with open(jpath) as data_file:
self._json = json.load(data_file)
if self._verbose:print("{} Updater: Read in json settings from file".format(self._addon))
else:
# set data structure
self._json = {
"last_check":"",
"backup_date":"",
"update_ready":False,
"ignore":False,
"just_restored":False,
"just_updated":False,
"version_text":{}
}
self.save_updater_json()
def save_updater_json(self):
# first save the state
if self._update_ready == True:
if type(self._update_version) == type((0,0,0)):
self._json["update_ready"] = True
self._json["version_text"]["link"]=self._update_link
self._json["version_text"]["version"]=self._update_version
else:
self._json["update_ready"] = False
self._json["version_text"] = {}
else:
self._json["update_ready"] = False
self._json["version_text"] = {}
jpath = os.path.join(self._updater_path,"updater_status.json")
outf = open(jpath,'w')
data_out = json.dumps(self._json,indent=4)
outf.write(data_out)
outf.close()
if self._verbose:
print(self._addon+": Wrote out updater json settings to file, with the contents:")
print(self._json)
def json_reset_postupdate(self):
self._json["just_updated"] = False
self._json["update_ready"] = False
self._json["version_text"] = {}
self.save_updater_json()
def json_reset_restore(self):
self._json["just_restored"] = False
self._json["update_ready"] = False
self._json["version_text"] = {}
self.save_updater_json()
self._update_ready = None # reset so you could check update again
def ignore_update(self):
self._json["ignore"] = True
self.save_updater_json()
# -------------------------------------------------------------------------
# ASYNC stuff
# -------------------------------------------------------------------------
def start_async_check_update(self, now=False,callback=None):
if self._async_checking == True:
return
if self._verbose: print("{} updater: Starting background checking thread".format(self._addon))
check_thread = threading.Thread(target=self.async_check_update,
args=(now,callback,))
check_thread.daemon = True
self._check_thread = check_thread
check_thread.start()
return True
def async_check_update(self, now, callback=None):
self._async_checking = True
if self._verbose:print("{} BG thread: Checking for update now in background".format(self._addon))
# time.sleep(3) # to test background, in case internet too fast to tell
# try:
self.check_for_update(now=now)
# except Exception as exception:
# print("Checking for update error:")
# print(exception)
# self._update_ready = False
# self._update_version = None
# self._update_link = None
# self._error = "Error occurred"
# self._error_msg = "Encountered an error while checking for updates"
if self._verbose:
print("{} BG thread: Finished checking for update, doing callback".format(self._addon))
if callback is not None:callback(self._update_ready)
self._async_checking = False
self._check_thread = None
def stop_async_check_update(self):
if self._check_thread is not None:
try:
if self._verbose:print("Thread will end in normal course.")
# however, "There is no direct kill method on a thread object."
# better to let it run its course
#self._check_thread.stop()
except:
pass
self._async_checking = False
self._error = None
self._error_msg = None
# -----------------------------------------------------------------------------
# The module-shared class instance,
# should be what's imported to other files
# -----------------------------------------------------------------------------
Updater = Singleton_updater()
