#!/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
"""
test
"""
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
"""
UpdaterServiceSetting
"""
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()