347 lines
11 KiB
GDScript
347 lines
11 KiB
GDScript
extends Node
|
|
## -----------------------------------------------------------------------------
|
|
## Checks to see if there is a better version of GUT available for a version of
|
|
## Godot. The data used to validate the GUT version includes lower and upper
|
|
## Godot versions
|
|
##
|
|
## There are 3 places where version information is located.
|
|
## * LOCAL_FILE_PATH: This is the version information that is packed with this
|
|
## release of GUT. It serves as a fallback if remote data is not available.
|
|
## This is most useful in detecting that GUT is being used with an earlier
|
|
## release of Godot and remote data is not available.
|
|
## * REMOTE_FILE_URL: This is where the the version information exists outside
|
|
## of the local copy of GUT. This data will be downlaoded to REMOTE_FILE_PATH
|
|
## whenever remote data is fetched.
|
|
## * REMOTE_FILE_PATH: This is where REMOTE_FILE_URL is downloaded to. When
|
|
## the file is downloaded, timetamp information is added to the data so that
|
|
## we can avoid downloading the file too often. This file is used whenever
|
|
## it exists. If it does not exist and we don't fetch it, LOCAL_FILE_PATH
|
|
## will be used.
|
|
##
|
|
## REMOTE_FILE_URL Location
|
|
## Currently this file points to a file on the main branch. This is the same
|
|
## file that will be shipped with each version of GUT. This allows the file to
|
|
## be updated and still be shipped with each version of GUT.
|
|
## -----------------------------------------------------------------------------
|
|
var Vnt = load("res://addons/gut/version_numbers.gd").VerNumTools
|
|
|
|
|
|
const REMOTE_FILE_URL = "https://api.github.com/repos/bitwes/gut/contents/addons/gut/versions.json"
|
|
const LOCAL_FILE_PATH = "res://addons/gut/versions.json"
|
|
const REMOTE_FILE_PATH = "user://gut_temp_directory/versions.json"
|
|
const VERSION_ZERO = "0.0.0"
|
|
|
|
class VersionData:
|
|
var _data := {}
|
|
var data_issues = []
|
|
const VERSION_ZERO = "0.0.0"
|
|
|
|
var Vnt = load("res://addons/gut/version_numbers.gd").VerNumTools
|
|
|
|
|
|
func is_gut_version_valid(gut_v, godot_v):
|
|
if(_data.releases.has(gut_v)):
|
|
var entry = _data.releases[gut_v]
|
|
return Vnt.is_version_gte(godot_v, entry.godot_min) and Vnt.is_version_lte(godot_v, entry.godot_max)
|
|
else:
|
|
return false
|
|
|
|
|
|
func parse_data(new_data):
|
|
data_issues.clear()
|
|
_data = {}
|
|
if(typeof(new_data) == TYPE_STRING):
|
|
_data = JSON.parse_string(new_data)
|
|
elif(typeof(new_data) == TYPE_DICTIONARY):
|
|
_data = new_data
|
|
|
|
if(!_data.has('asset_library')):
|
|
data_issues.append("asset_library entry missing")
|
|
|
|
if(_data.has('releases')):
|
|
for key in _data.releases:
|
|
var entry = _data.releases[key]
|
|
if(!entry.has('godot_min')):
|
|
data_issues.append(str(key, ' missing godot_min'))
|
|
if(!entry.has('godot_max')):
|
|
data_issues.append(str(key, ' missing godot_max'))
|
|
else:
|
|
data_issues.append('missing releases entry')
|
|
|
|
if(_data.has('branches')):
|
|
for key in _data.branches:
|
|
var entry = _data.branches[key]
|
|
if(!entry.has('godot_min')):
|
|
data_issues.append(str(key, ' missing godot_min'))
|
|
if(!entry.has('godot_max')):
|
|
data_issues.append(str(key, ' missing godot_max'))
|
|
else:
|
|
data_issues.append('missing branches entry')
|
|
|
|
|
|
func parse_file(path):
|
|
if(FileAccess.file_exists(path)):
|
|
var text = GutUtils.get_file_as_text(path)
|
|
parse_data(text)
|
|
else:
|
|
_data = {}
|
|
|
|
|
|
func get_gut_version_for_godot_version(godot_v=null):
|
|
var to_return = VERSION_ZERO
|
|
if(is_empty()):
|
|
return to_return
|
|
|
|
if(godot_v == null):
|
|
godot_v = GutUtils.version_numbers.make_godot_version_string()
|
|
|
|
for key in _data.releases:
|
|
var entry = _data.releases[key]
|
|
if(Vnt.is_version_gte(godot_v, entry.godot_min) and Vnt.is_version_lte(godot_v, entry.godot_max)):
|
|
if(Vnt.is_version_gte(key, to_return)):
|
|
to_return = key
|
|
|
|
if(to_return == VERSION_ZERO and _data.has('branches')):
|
|
for key in _data.branches:
|
|
var entry = _data.branches[key]
|
|
if(Vnt.is_version_gte(godot_v, entry.godot_min) and Vnt.is_version_lte(godot_v, entry.godot_max)):
|
|
to_return = key
|
|
|
|
return to_return
|
|
|
|
func is_empty():
|
|
return _data.is_empty()
|
|
|
|
func clear():
|
|
_data.clear()
|
|
data_issues.clear()
|
|
|
|
## See comment in get_update_string
|
|
# func is_in_asset_library(gut_v):
|
|
# if(_data.has('asset_library')):
|
|
# return _data.asset_library == gut_v
|
|
# else:
|
|
# return false
|
|
|
|
func get_data():
|
|
return _data.duplicate(true)
|
|
|
|
|
|
var _http_request : HTTPRequest
|
|
var local_data : VersionData = VersionData.new()
|
|
var remote_data : VersionData = VersionData.new()
|
|
|
|
var min_fetch_wait = 60 * 60 # 1 hour
|
|
|
|
signal download_completed()
|
|
signal updated()
|
|
|
|
|
|
func _ready() -> void:
|
|
_setup_http_request(HTTPRequest.new())
|
|
|
|
|
|
func _setup_http_request(request):
|
|
_http_request = request
|
|
add_child(_http_request)
|
|
_http_request.timeout = 3.0
|
|
_http_request.request_completed.connect(self._http_request_completed)
|
|
|
|
|
|
func _write_remote_file(data):
|
|
data.fetch_timestamp = Time.get_unix_time_from_system()
|
|
GutUtils.write_file(REMOTE_FILE_PATH, JSON.stringify(data))
|
|
|
|
|
|
func _url_formatter(url, link_text=null):
|
|
if(link_text == null):
|
|
return url
|
|
else:
|
|
return str(link_text, ': ', url)
|
|
|
|
|
|
#------------
|
|
# Events
|
|
#------------
|
|
# Called when the HTTP request is completed.
|
|
func _http_request_completed(result, response_code, headers, body):
|
|
var body_text = body.get_string_from_utf8()
|
|
|
|
if(response_code == 200):
|
|
var json = JSON.new()
|
|
var err = json.parse(body_text)
|
|
if(err != OK):
|
|
push_error("[GUT] Invalid JSON: ", json.get_error_message(), '. ', body_text)
|
|
download_completed.emit()
|
|
return
|
|
var response = json.get_data()
|
|
|
|
remote_data.parse_data(response)
|
|
if(remote_data.data_issues.size() == 0):
|
|
_write_remote_file(response.duplicate(true))
|
|
else:
|
|
push_error("[GUT] Invalid version data: ", remote_data.data_issues)
|
|
remote_data.clear()
|
|
else:
|
|
var json = JSON.new()
|
|
var err = json.parse(body_text)
|
|
var response = {}
|
|
if(err == OK):
|
|
response = json.get_data()
|
|
|
|
var msg = ''
|
|
if(response != null and response.has('message')):
|
|
msg = str(" (", response.message, ")")
|
|
push_error("[GUT] Could not get version info, response code: ", response_code, msg)
|
|
|
|
download_completed.emit()
|
|
|
|
|
|
func _is_branch_version(v : String):
|
|
return v.find(".") == -1
|
|
#------------
|
|
# Public
|
|
#------------
|
|
func fetch_remote_file():
|
|
var headers : PackedStringArray = [
|
|
"Accept: application/vnd.github.raw",
|
|
"X-GitHub-Api-Version: 2022-11-28"
|
|
]
|
|
var error = _http_request.request(REMOTE_FILE_URL, headers)
|
|
if error != OK:
|
|
var errtxt = str("[GUT] An error occurred requesting version data: ", error, ".")
|
|
remote_data.data_issues.append(errtxt)
|
|
push_error(errtxt)
|
|
return error
|
|
|
|
|
|
func get_gut_version_for_godot_version(godot_v=null):
|
|
var to_return = VERSION_ZERO
|
|
if(godot_v == null):
|
|
godot_v = GutUtils.version_numbers.make_godot_version_string()
|
|
|
|
var remote_latest = remote_data.get_gut_version_for_godot_version(godot_v)
|
|
var local_latest = local_data.get_gut_version_for_godot_version(godot_v)
|
|
|
|
if(remote_latest == VERSION_ZERO and local_latest != VERSION_ZERO):
|
|
to_return = local_latest
|
|
elif(remote_latest != VERSION_ZERO and local_latest == VERSION_ZERO):
|
|
to_return = remote_latest
|
|
elif(_is_branch_version(remote_latest) and !_is_branch_version(local_latest)):
|
|
to_return = local_latest
|
|
elif(Vnt.is_version_gte(remote_latest, local_latest)):
|
|
to_return = remote_latest
|
|
else:
|
|
to_return = local_latest
|
|
|
|
return to_return
|
|
|
|
|
|
func is_gut_version_valid(gut_v =null, godot_v=null):
|
|
if(gut_v == null):
|
|
gut_v = GutUtils.version_numbers.gut_version
|
|
godot_v = GutUtils.version_numbers.make_godot_version_string()
|
|
|
|
if(!local_data.is_empty() and !remote_data.is_empty()):
|
|
return local_data.is_gut_version_valid(gut_v, godot_v) or \
|
|
remote_data.is_gut_version_valid(gut_v, godot_v)
|
|
else:
|
|
return true
|
|
|
|
## See comment in get_update_string
|
|
# func is_in_asset_library(gut_v):
|
|
# if(remote_data._data.has('asset_library')):
|
|
# return remote_data._data.asset_library == gut_v
|
|
# else:
|
|
# return false
|
|
|
|
|
|
func check_for_update():
|
|
local_data.parse_file(LOCAL_FILE_PATH)
|
|
if(FileAccess.file_exists(REMOTE_FILE_PATH)):
|
|
remote_data.parse_file(REMOTE_FILE_PATH)
|
|
|
|
updated.emit.call_deferred()
|
|
|
|
|
|
func check_for_update_with_fetch(force=false):
|
|
remote_data.parse_file(REMOTE_FILE_PATH)
|
|
var time_since_last_fetch = 60 * 60 * 24 * 10_000 # ten thousand days
|
|
|
|
if(remote_data._data.has("fetch_timestamp")):
|
|
time_since_last_fetch = Time.get_unix_time_from_system() - remote_data._data.fetch_timestamp
|
|
|
|
if(force or time_since_last_fetch > min_fetch_wait):
|
|
fetch_remote_file()
|
|
await download_completed
|
|
|
|
check_for_update()
|
|
|
|
|
|
func get_update_string(url_formatter:Callable=_url_formatter):
|
|
var gut_v = GutUtils.version_numbers.gut_version
|
|
var godot_v = GutUtils.godot_version_string()
|
|
var version_info = str("GUT ", gut_v, " is the lastest version for Godot ", godot_v)
|
|
|
|
var rec_ver = get_gut_version_for_godot_version(godot_v)
|
|
var rec_ver_link = url_formatter.call(str("https://github.com/bitwes/Gut/releases/tag/v", rec_ver), str("GUT ",rec_ver))
|
|
|
|
if(is_gut_version_valid(gut_v, godot_v)):
|
|
if(rec_ver != gut_v):
|
|
version_info = str(rec_ver_link, ' is now available!')
|
|
else:
|
|
if(rec_ver.find(".") == -1):
|
|
version_info = str("GUT does not have a release for this version of Godot yet, but it does have ",
|
|
"the branch '", rec_ver, "'.\n",
|
|
"Check the readme for install links/instructions: ", url_formatter.call('https://github.com/bitwes/Gut'))
|
|
else:
|
|
version_info = str('This version of GUT may not be compatible with Godot ', godot_v, '. ')
|
|
if(rec_ver == '0.0.0'):
|
|
version_info += str("No release or branch exists for this version of Godot yet. Check back soon.")
|
|
else:
|
|
version_info += str('Consider changing to ', rec_ver_link)
|
|
## Commented this out for now, this needs to be reassessed for the new store
|
|
## For now I'm leaving it out as I don't know what the urls look like or have
|
|
## anything out there yet.
|
|
# if(rec_ver != gut_v and is_in_asset_library(rec_ver)):
|
|
# version_info += str("\nYou can update to ", rec_ver, " through the Asset Library.")
|
|
return version_info
|
|
|
|
|
|
func get_summary_string():
|
|
var gut_v = GutUtils.version_numbers.gut_version
|
|
var godot_v = GutUtils.godot_version_string()
|
|
|
|
return str("GUT: ", gut_v, "\n",
|
|
"Godot: ", godot_v, "\n",
|
|
"Valid: ", is_gut_version_valid(gut_v, godot_v), "\n",
|
|
"Latest: ", get_gut_version_for_godot_version(godot_v))
|
|
|
|
|
|
func fetch_limit_wait_time():
|
|
var remaining = -1
|
|
if(remote_data.get_data().has("fetch_timestamp")):
|
|
var time_since_last_fetch = Time.get_unix_time_from_system() - remote_data._data.fetch_timestamp
|
|
return max(min_fetch_wait - time_since_last_fetch, 0.0)
|
|
else:
|
|
return -1
|
|
|
|
|
|
func get_days_since_last_fetch():
|
|
var to_return = 99
|
|
if(remote_data.get_data().has("fetch_timestamp")):
|
|
var time_since_last_fetch = Time.get_unix_time_from_system() - remote_data._data.fetch_timestamp
|
|
to_return = time_since_last_fetch / (60.0 * 60.0 * 24.0)
|
|
return to_return
|
|
|
|
|
|
func is_empty():
|
|
return local_data.is_empty() and remote_data.is_empty()
|
|
|
|
|
|
func get_all_data():
|
|
return {
|
|
local_data:local_data.get_data(),
|
|
remote_data:remote_data.get_data()
|
|
}
|