456 lines
22 KiB
Python
Executable File
456 lines
22 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
# $LicenseInfo:firstyear=2016&license=internal$
|
|
#
|
|
# Copyright (c) 2016, Linden Research, Inc.
|
|
#
|
|
# The following source code is PROPRIETARY AND CONFIDENTIAL. Use of
|
|
# this source code is governed by the Linden Lab Source Code Disclosure
|
|
# Agreement ("Agreement") previously entered between you and Linden
|
|
# Lab. By accessing, using, copying, modifying or distributing this
|
|
# software, you acknowledge that you have been informed of your
|
|
# obligations under the Agreement and agree to abide by those obligations.
|
|
#
|
|
# ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
# WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
# COMPLETENESS OR PERFORMANCE.
|
|
# $/LicenseInfo$
|
|
# Copyright (c) 2013, Linden Research, Inc.
|
|
|
|
"""
|
|
@file update_manager.py
|
|
@author coyot
|
|
@date 2016-05-16
|
|
"""
|
|
|
|
from llbase import llrest
|
|
from llbase import llsd
|
|
from urlparse import urljoin
|
|
|
|
import apply_update
|
|
import download_update
|
|
import errno
|
|
import fnmatch
|
|
import hashlib
|
|
import InstallerUserMessage
|
|
import json
|
|
import os
|
|
import platform
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import thread
|
|
import urllib
|
|
|
|
def silent_write(log_file_handle, text):
|
|
#if we have a log file, write. If not, do nothing.
|
|
#this is so we don't have to keep trapping for an exception with a None handle
|
|
#oh and because it is best effort, it is also a holey_write ;)
|
|
if (log_file_handle):
|
|
#prepend text for easy grepping
|
|
log_file_handle.write("UPDATE MANAGER: " + text + "\n")
|
|
|
|
def after_frame(my_message, timeout = 10000):
|
|
#pop up a InstallerUserMessage.basic_message that kills itself after timeout milliseconds
|
|
#note that this blocks the caller for the duration of timeout
|
|
frame = InstallerUserMessage(title = "Second Life Installer", icon_name="head-sl-logo.gif")
|
|
#this is done before basic_message so that we aren't blocked by mainloop()
|
|
frame.after(timout, lambda: frame._delete_window)
|
|
frame.basic_message(message = my_message)
|
|
|
|
def convert_version_file_style(version):
|
|
#converts a version string a.b.c.d to a_b_c_d as used in downloaded filenames
|
|
#re will throw a TypeError if it gets None, just return that.
|
|
try:
|
|
pattern = re.compile('\.')
|
|
return pattern.sub('_', version)
|
|
except TypeError, te:
|
|
return None
|
|
|
|
def get_platform_key():
|
|
#this is the name that is inserted into the VVM URI
|
|
#and carried forward through the rest of the updater to determine
|
|
#platform specific actions as appropriate
|
|
platform_dict = {'Darwin':'mac', 'Linux':'lnx', 'Windows':'win'}
|
|
platform_uname = platform.system()
|
|
try:
|
|
return platform_dict[platform_uname]
|
|
except KeyError:
|
|
return None
|
|
|
|
def get_summary(platform_name, launcher_path):
|
|
#get the contents of the summary.json file.
|
|
#for linux and windows, this file is in the same directory as the script
|
|
#for mac, the script is in ../Contents/MacOS/ and the file is in ../Contents/Resources/
|
|
script_dir = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
|
|
if (platform_name == 'mac'):
|
|
summary_dir = os.path.abspath(os.path.join(script_dir, "../Resources"))
|
|
else:
|
|
summary_dir = script_dir
|
|
summary_file = os.path.join(summary_dir,"summary.json")
|
|
with open(summary_file) as summary_handle:
|
|
return json.load(summary_handle)
|
|
|
|
def get_parent_path(platform_name):
|
|
#find the parent of the logs and user_settings directories
|
|
if (platform_name == 'mac'):
|
|
settings_dir = os.path.join(os.path.expanduser('~'),'Library','Application Support','SecondLife')
|
|
elif (platform_name == 'lnx'):
|
|
settings_dir = os.path.join(os.path.expanduser('~'),'.secondlife')
|
|
#using list format of join is important here because the Windows pathsep in a string escapes the next char
|
|
elif (platform_name == 'win'):
|
|
settings_dir = os.path.join(os.path.expanduser('~'),'AppData','Roaming','SecondLife')
|
|
else:
|
|
settings_dir = None
|
|
return settings_dir
|
|
|
|
def make_download_dir(parent_dir, new_version):
|
|
#make a canonical download dir if it does not already exist
|
|
#format: ../user_settings/downloads/1.2.3.456789
|
|
#we do this so that multiple viewers on the same host can update separately
|
|
#this also functions as a getter
|
|
try:
|
|
download_dir = os.path.join(parent_dir, "downloads", new_version)
|
|
os.makedirs(download_dir)
|
|
except OSError, hell:
|
|
#Directory already exists, that's okay. Other OSErrors are not okay.
|
|
if hell[0] == errno.EEXIST:
|
|
pass
|
|
else:
|
|
raise hell
|
|
return download_dir
|
|
|
|
def check_for_completed_download(download_dir):
|
|
#there will be two files on completion, the download and a marker file called "".done""
|
|
#for optional upgrades, there may also be a .skip file to skip this particular upgrade
|
|
#or .next to install on next run
|
|
completed = None
|
|
marker_regex = '*' + '.done'
|
|
skip_regex = '*' + '.skip'
|
|
next_regex = '*' + '.next'
|
|
for filename in os.listdir(download_dir):
|
|
if fnmatch.fnmatch(filename, marker_regex):
|
|
completed = 'done'
|
|
elif fnmatch.fnmatch(filename, skip_regex):
|
|
completed = 'skip'
|
|
elif fnmatch.fnmatch(filename, next_regex):
|
|
#so we don't skip infinitely
|
|
os.remove(filename)
|
|
completed = 'next'
|
|
if not completed:
|
|
#cleanup
|
|
shutil.rmtree(download_dir)
|
|
return completed
|
|
|
|
def get_settings(log_file_handle, parent_dir):
|
|
#return the settings file parsed into a dict
|
|
try:
|
|
settings_file = os.path.abspath(os.path.join(parent_dir,'user_settings','settings.xml'))
|
|
settings = llsd.parse((open(settings_file)).read())
|
|
except llsd.LLSDParseError as lpe:
|
|
silent_write(log_file_handle, "Could not parse settings file %s" % lpe)
|
|
return None
|
|
return settings
|
|
|
|
def get_log_file_handle(parent_dir):
|
|
#return a write handle on the log file
|
|
#plus log rotation and not dying on failure
|
|
log_file = os.path.join(parent_dir, 'update_manager.log')
|
|
old_file = log_file + '.old'
|
|
#if someone's log files are present but not writable, they've screwed up their install.
|
|
if os.access(log_file, os.W_OK):
|
|
if os.access(old_file, os.W_OK):
|
|
os.unlink(old_file)
|
|
os.rename(log_file, old_file)
|
|
elif not os.path.exists(log_file):
|
|
#reimplement TOUCH(1) in Python
|
|
#perms default to 644 which is fine
|
|
open(log_file, 'w+').close()
|
|
try:
|
|
f = open(log_file,'w+')
|
|
except Exception as e:
|
|
#we don't have a log file to write to, make a best effort and sally onward
|
|
print "Could not open update manager log file %s" % log_file
|
|
f = None
|
|
return f
|
|
|
|
def make_VVM_UUID_hash(platform_key):
|
|
#NOTE: There is no python library support for a persistent machine specific UUID
|
|
# AND all three platforms do this a different way, so exec'ing out is really the best we can do
|
|
#Lastly, this is a best effort service. If we fail, we should still carry on with the update
|
|
uuid = None
|
|
if (platform_key == 'lnx'):
|
|
uuid = subprocess.check_output(['/usr/bin/hostid']).rstrip()
|
|
elif (platform_key == 'mac'):
|
|
#this is absurdly baroque
|
|
#/usr/sbin/system_profiler SPHardwareDataType | fgrep 'Serial' | awk '{print $NF}'
|
|
uuid = subprocess.check_output(["/usr/sbin/system_profiler", "SPHardwareDataType"])
|
|
#findall[0] does the grep for the value we are looking for: "Serial Number (system): XXXXXXXX"
|
|
#split(:)[1] gets us the XXXXXXX part
|
|
#lstrip shaves off the leading space that was after the colon
|
|
uuid = re.split(":", re.findall('Serial Number \(system\): \S*', uuid)[0])[1].lstrip()
|
|
elif (platform_key == 'win'):
|
|
# wmic csproduct get UUID | grep -v UUID
|
|
uuid = subprocess.check_output(['wmic','csproduct','get','UUID'])
|
|
#outputs in two rows:
|
|
#UUID
|
|
#XXXXXXX-XXXX...
|
|
uuid = re.split('\n',uuid)[1].rstrip()
|
|
if uuid is not None:
|
|
return hashlib.md5(uuid).hexdigest()
|
|
else:
|
|
#fake it
|
|
return hashlib.md5(str(uuid.uuid1())).hexdigest()
|
|
|
|
def query_vvm(log_file_handle, platform_key, settings, summary_dict):
|
|
result_data = None
|
|
#URI template /update/v1.1/channelname/version/platformkey/platformversion/willing-to-test/uniqueid
|
|
#https://wiki.lindenlab.com/wiki/Viewer_Version_Manager_REST_API#Viewer_Update_Query
|
|
base_URI = 'https://update.secondlife.com/update/'
|
|
channelname = summary_dict['Channel']
|
|
#this is kind of a mess because the settings value a) in a map and b) is both the cohort and the version
|
|
version = summary_dict['Version']
|
|
platform_version = platform.release()
|
|
#this will always return something usable, error handling in method
|
|
hashed_UUID = make_VVM_UUID_hash(platform_key)
|
|
#note that this will not normally be in a settings.xml file and is only here for test builds.
|
|
#for test builds, add this key to the ../user_settings/settings.xml
|
|
"""
|
|
<key>test</key>
|
|
<map>
|
|
<key>Comment</key>
|
|
<string>Tell update manager you aren't willing to test.</string>
|
|
<key>Type</key>
|
|
<string>String</string>
|
|
<key>Value</key>
|
|
<integer>testno</integer>
|
|
</map>
|
|
</map>
|
|
"""
|
|
try:
|
|
test_ok = settings['test']['Value']
|
|
except KeyError as ke:
|
|
#normal case, no testing key
|
|
test_ok = 'testok'
|
|
UUID = make_VVM_UUID_hash(platform_key)
|
|
#because urljoin can't be arsed to take multiple elements
|
|
query_string = '/v1.0/' + channelname + '/' + version + '/' + platform_key + '/' + platform_version + '/' + test_ok + '/' + UUID
|
|
VVMService = llrest.SimpleRESTService(name='VVM', baseurl=base_URI)
|
|
try:
|
|
result_data = VVMService.get(query_string)
|
|
except RESTError as re:
|
|
silent_write.write(log_file_handle, "Failed to query VVM using %s failed as %s" % (urljoin(base_URI,query_string, re)))
|
|
return None
|
|
return result_data
|
|
|
|
def download(url = None, version = None, download_dir = None, size = 0, background = False):
|
|
download_tries = 0
|
|
download_success = False
|
|
#for background execution
|
|
path_to_downloader = os.path.join(os.path.dirname(os.path.realpath(__file__)), "download_update.py")
|
|
#three strikes and you're out
|
|
while download_tries < 3 and not download_success:
|
|
#323: Check for a partial update of the required update; in either event, display an alert that a download is required, initiate the download, and then install and launch
|
|
if download_tries == 0:
|
|
after_frame(message = "Downloading new version " + version + " Please wait.")
|
|
else:
|
|
after_frame(message = "Trying again to download new version " + version + " Please wait.")
|
|
if not background:
|
|
try:
|
|
download_update.download_update(url = url, download_dir = download_dir, size = size, progressbar = True)
|
|
download_success = True
|
|
except:
|
|
download_tries += 1
|
|
silent_write(log_file_handle, "Failed to download new version " + version + ". Trying again.")
|
|
else:
|
|
try:
|
|
#Python does not have a facility to multithread a method, so we make the method a standalone
|
|
#and subprocess that
|
|
subprocess.call(path_to_downloader, "--url = %s --dir = %s --pb --size= %s" % (url, download_dir, size))
|
|
download_success = True
|
|
except:
|
|
download_tries += 1
|
|
silent_write(log_file_handle, "Failed to download new version " + version + ". Trying again.")
|
|
if not download_success:
|
|
silent_write(log_file_handle, "Failed to download new version " + version)
|
|
after_frame(message = "Failed to download new version " + version + " Please check connectivity.")
|
|
return False
|
|
return True
|
|
|
|
def install(platform_key = None, download_dir = None, log_file_handle = None, in_place = None, downloaded = None):
|
|
#user said no to this one
|
|
if downloaded != 'skip':
|
|
after_frame(message = "New version downloaded. Installing now, please wait.")
|
|
success = apply_update.apply_update(download_dir, platform_key, log_file_handle, in_place)
|
|
if success:
|
|
silent_write(log_file_handle, "successfully updated to " + version)
|
|
shutil.rmtree(download_dir)
|
|
#this is either True for in place or the path to the new install for not in place
|
|
return success
|
|
else:
|
|
after_frame(message = "Failed to apply " + version)
|
|
silent_write(log_file_handle, "Failed to update viewer to " + version)
|
|
return False
|
|
|
|
def download_and_install(downloaded = None, url = None, version = None, download_dir = None, size = None, platform_key = None, log_file_handle = None, in_place = None):
|
|
#extracted to a method because we do it twice in update_manager() and this makes the logic clearer
|
|
if not downloaded:
|
|
#do the download, exit if we fail
|
|
if not download(url = url, version = version, download_dir = download_dir, size = size):
|
|
return (False, 'download', version)
|
|
#do the install
|
|
path_to_new_launcher = install(platform_key = platform_key, download_dir = download_dir,
|
|
log_file_handle = log_file_handle, in_place = in_place, downloaded = downloaded)
|
|
if path_to_new_launcher:
|
|
#if we succeed, propagate the success type upwards
|
|
if in_place:
|
|
return (True, 'in place', True)
|
|
else:
|
|
return (True, 'in place', path_to_new_launcher)
|
|
else:
|
|
#propagate failure
|
|
return (False, 'apply', version)
|
|
|
|
def update_manager():
|
|
#comments that begin with '323:' are steps taken from the algorithm in the description of SL-323.
|
|
# Note that in the interest of efficiency, such as determining download success once at the top
|
|
# The code does follow precisely the same order as the algorithm.
|
|
#return values rather than exit codes. All of them are to communicate with launcher
|
|
#we print just before we return so that __main__ outputs something - returns are swallowed
|
|
# (False, 'setup', None): error occurred before we knew what the update was (e.g., in setup or parsing)
|
|
# (False, 'download', version): we failed to download the new version
|
|
# (False, 'apply', version): we failed to apply the new version
|
|
# (True, None, None): No update found
|
|
# (True, 'in place, True): update applied in place
|
|
# (True, 'in place', path_to_new_launcher): Update applied by a new install to a new location
|
|
# (True, 'background', True): background download initiated
|
|
|
|
#setup and getting initial parameters
|
|
platform_key = get_platform_key()
|
|
parent_dir = get_parent_path(platform_key)
|
|
log_file_handle = get_log_file_handle(parent_dir)
|
|
|
|
#check to see if user has install rights
|
|
#get the owner of the install and the current user
|
|
script_owner_id = os.stat(os.path.realpath(__file__)).st_uid
|
|
user_id = os.geteuid()
|
|
#if we are on lnx or mac, we can pretty print the IDs as names using the pwd module
|
|
#win does not provide this support and Python will throw an ImportError there, so just use raw IDs
|
|
if script_owner_id != user_id:
|
|
if platform_key != 'win':
|
|
import pwd
|
|
script_owner_name = pwd.getpwuid(script_owner_id)[0]
|
|
username = pwd.getpwuid(user_id)[0]
|
|
else:
|
|
username = user_id
|
|
script_owner_name = script_owner_id
|
|
silent_write(log_file_handle, "Upgrade notification attempted by userid " + username)
|
|
frame = InstallerUserMessage(title = "Second Life Installer", icon_name="head-sl-logo.gif")
|
|
frame.binary_choice_message(message = "Second Life was installed by userid " + script_owner_name
|
|
+ ". Do you have privileges to install?", true = "Yes", false = 'No')
|
|
if not frame.choice.get():
|
|
silent_write(log_file_handle, "Upgrade attempt declined by userid " + username)
|
|
after_frame(message = "Please find a system admin to upgrade Second Life")
|
|
print "Update manager exited with (%s, %s, %s)" % (False, 'setup', None)
|
|
return (False, 'setup', None)
|
|
|
|
settings = get_settings(log_file_handle, parent_dir)
|
|
if settings is None:
|
|
silent_write(log_file_handle, "Failed to load viewer settings")
|
|
print "Update manager exited with (%s, %s, %s)" % (False, 'setup', None)
|
|
return (False, 'setup', None)
|
|
|
|
#323: If a complete download of that update is found, check the update preference:
|
|
#settings['UpdaterServiceSetting'] = 0 is manual install
|
|
"""
|
|
<key>UpdaterServiceSetting</key>
|
|
<map>
|
|
<key>Comment</key>
|
|
<string>Configure updater service.</string>
|
|
<key>Type</key>
|
|
<string>U32</string>
|
|
<key>Value</key>
|
|
<string>0</string>
|
|
</map>
|
|
"""
|
|
try:
|
|
install_automatically = settings['UpdaterServiceSetting']['Value']
|
|
#because, for some godforsaken reason, we delete the setting rather than changing the value
|
|
except KeyError:
|
|
install_automatically = 1
|
|
|
|
#get channel and version
|
|
try:
|
|
summary_dict = get_summary(platform_key, os.path.abspath(os.path.realpath(__file__)))
|
|
except:
|
|
silent_write(log_file_handle, "Could not obtain channel and version, exiting.")
|
|
print "Update manager exited with (%s, %s, %s)" % (False, 'setup', None)
|
|
return (False, 'setup', None)
|
|
|
|
#323: On launch, the Viewer Manager should query the Viewer Version Manager update api.
|
|
result_data = query_vvm(log_file_handle, platform_key, settings, summary_dict)
|
|
#nothing to do or error
|
|
if not result_data:
|
|
silent_write.write(og_file_handle, "No update found.")
|
|
print "Update manager exited with (%s, %s, %s)" % (True, None, None)
|
|
return (True, None, None)
|
|
|
|
#get download directory, if there are perm issues or similar problems, give up
|
|
try:
|
|
download_dir = make_download_dir(parent_dir, result_data['version'])
|
|
except Exception, e:
|
|
print "Update manager exited with (%s, %s, %s)" % (False, 'setup', None)
|
|
return (False, 'setup', None)
|
|
|
|
#if the channel name of the response is the same as the channel we are launched from, the update is "in place"
|
|
#and launcher will launch the viewer in this install location. Otherwise, it will launch the Launcher from
|
|
#the new location and kill itself.
|
|
in_place = (summary_dict['Channel'] == result_data['channel'])
|
|
|
|
#determine if we've tried this download before
|
|
downloaded = check_for_completed_download(download_dir)
|
|
|
|
#323: If the response indicates that there is a required update:
|
|
if result_data['required'] or (not result_data['required'] and install_automatically):
|
|
#323: Check for a completed download of the required update; if found, display an alert, install the required update, and launch the newly installed viewer.
|
|
#323: If [optional download and] Install Automatically: display an alert, install the update and launch updated viewer.
|
|
return download_and_install(downloaded = downloaded, url = result_data['url'], version = result_data['version'], download_dir = download_dir,
|
|
size = result_data['size'], platform_key = platform_key, log_file_handle = log_file_handle, in_place = in_place)
|
|
else:
|
|
#323: If the update response indicates that there is an optional update:
|
|
#323: Check to see if the optional update has already been downloaded.
|
|
#323: If a complete download of that update is found, check the update preference:
|
|
#note: automatic install handled above as the steps are the same as required upgrades
|
|
#323: If Install Manually: display a message with the update information and ask the user whether or not to install the update with three choices:
|
|
#323: Skip this update: create a marker that subsequent launches should not prompt for this update as long as it is optional,
|
|
# but leave the download in place so that if it becomes required it will be there.
|
|
#323: Install next time: create a marker that skips the prompt and installs on the next launch
|
|
#323: Install and launch now: do it.
|
|
if downloaded is not None and downloaded != 'skip':
|
|
frame = InstallerUserMessage(title = "Second Life Installer", icon_name="head-sl-logo.gif")
|
|
#The choices are reordered slightly to encourage immediate install and slightly discourage skipping
|
|
frame.trinary_message(message = "Please make a selection",
|
|
one = "Install new version now.", two = 'Install the next time the viewer is launched.', three = 'Skip this update.')
|
|
choice = frame.choice.get()
|
|
if choice == 1:
|
|
return download_and_install(downloaded = downloaded, url = result_data['url'], version = result_data['version'], download_dir = download_dir,
|
|
size = result_data['size'], platform_key = platform_key, log_file_handle = log_file_handle, in_place = in_place)
|
|
elif choice == 2:
|
|
tempfile.mkstmp(suffix = ".next", dir = download_dir)
|
|
return (True, None, None)
|
|
else:
|
|
tempfile.mkstmp(suffix = ".skip", dir = download_dir)
|
|
return (True, None, None)
|
|
else:
|
|
#multithread a download
|
|
download(url = result_data['url'], version = result_data['version'], download_dir = download_dir, size = result_data['size'], background = True)
|
|
print "Update manager exited with (%s, %s, %s)" % (True, 'background', True)
|
|
return (True, 'background', True)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
#there is no argument parsing or other main() work to be done
|
|
update_manager()
|