blob: 91876995f8a6355ef68deec5c1c43361e5a156d9 [file] [log] [blame]
# Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Devserver module for handling update client requests."""
from __future__ import print_function
import base64
import collections
import fcntl
import json
import os
import subprocess
import sys
import threading
import time
import urllib2
import urlparse
import cherrypy
import build_util
import autoupdate_lib
import common_util
import devserver_constants as constants
import log_util
# pylint: disable=F0401
# Allow importing from aosp/system/update_engine/scripts when running from
# source tree. Used for importing update_payload if it is not in the system
# path.
lib_dir = os.path.join(os.path.dirname(__file__), '..', '..', 'aosp',
'system', 'update_engine', 'scripts')
if os.path.exists(lib_dir) and os.path.isdir(lib_dir):
sys.path.insert(1, lib_dir)
import update_payload
# If used by client in place of an pre-update version string, forces an update
# to the client regardless of the relative versions of the payload and client.
FORCED_UPDATE = 'ForcedUpdate'
# Module-local log function.
def _Log(message, *args):
return log_util.LogWithTag('UPDATE', message, *args)
class AutoupdateError(Exception):
"""Exception classes used by this module."""
def _ChangeUrlPort(url, new_port):
"""Return the URL passed in with a different port"""
scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
host_port = netloc.split(':')
if len(host_port) == 1:
host_port[1] = new_port
netloc = '%s:%s' % tuple(host_port)
return urlparse.urlunsplit((scheme, netloc, path, query, fragment))
def _NonePathJoin(*args):
"""os.path.join that filters None's from the argument list."""
return os.path.join(*filter(None, args))
class HostInfo(object):
"""Records information about an individual host.
attrs: Static attributes (legacy)
log: Complete log of recorded client entries
def __init__(self):
# A dictionary of current attributes pertaining to the host.
self.attrs = {}
# A list of pairs consisting of a timestamp and a dictionary of recorded
# attributes.
self.log = []
def __repr__(self):
return 'attrs=%s, log=%s' % (self.attrs, self.log)
def AddLogEntry(self, entry):
"""Append a new log entry."""
# Append a timestamp.
assert not 'timestamp' in entry, 'Oops, timestamp field already in use'
entry['timestamp'] = time.strftime('%Y-%m-%d %H:%M:%S')
# Add entry to hosts' message log.
class HostInfoTable(object):
"""Records information about a set of hosts who engage in update activity.
table: Table of information on hosts.
def __init__(self):
# A dictionary of host information. Keys are normally IP addresses.
self.table = {}
def __repr__(self):
return '%s' % self.table
def GetInitHostInfo(self, host_id):
"""Return a host's info object, or create a new one if none exists."""
return self.table.setdefault(host_id, HostInfo())
def GetHostInfo(self, host_id):
"""Return an info object for given host, if such exists."""
return self.table.get(host_id)
class UpdateMetadata(object):
"""Object containing metadata about an update payload."""
def __init__(self, sha1, sha256, size, is_delta_format, metadata_size,
self.sha1 = sha1
self.sha256 = sha256
self.size = size
self.is_delta_format = is_delta_format
self.metadata_size = metadata_size
self.metadata_hash = metadata_hash
class Autoupdate(build_util.BuildObject):
"""Class that contains functionality that handles Chrome OS update pings.
forced_image: path to an image to use for all updates.
payload_path: path to pre-generated payload to serve.
src_image: if specified, creates a delta payload from this image.
proxy_port: port of local proxy to tell client to connect to you
board: board for the image. Needed for pre-generating of updates.
copy_to_static_root: copies images generated from the cache to ~/static.
public_key: path to public key in PEM format.
critical_update: whether provisioned payload is critical.
max_updates: maximum number of updates we'll try to provision.
host_log: record full history of host update events.
_OLD_PAYLOAD_URL_PREFIX = '/static/archive'
_PAYLOAD_URL_PREFIX = '/static/'
_FILEINFO_URL_PREFIX = '/api/fileinfo/'
SHA1_ATTR = 'sha1'
SHA256_ATTR = 'sha256'
SIZE_ATTR = 'size'
ISDELTA_ATTR = 'is_delta'
METADATA_SIZE_ATTR = 'metadata_size'
METADATA_HASH_ATTR = 'metadata_hash'
def __init__(self, xbuddy, forced_image=None, payload_path=None,
proxy_port=None, src_image='', board=None,
copy_to_static_root=True, public_key=None,
critical_update=False, max_updates=-1, host_log=False,
*args, **kwargs):
super(Autoupdate, self).__init__(*args, **kwargs)
self.xbuddy = xbuddy
self.forced_image = forced_image
self.payload_path = payload_path
self.src_image = src_image
self.proxy_port = proxy_port
self.board = board or self.GetDefaultBoardID()
self.copy_to_static_root = copy_to_static_root
self.public_key = public_key
self.critical_update = critical_update
self.max_updates = max_updates
self.host_log = host_log
self.pregenerated_path = None
# Initialize empty host info cache. Used to keep track of various bits of
# information about a given host. A host is identified by its IP address.
# The info stored for each host includes a complete log of events for this
# host, as well as a dictionary of current attributes derived from events.
self.host_infos = HostInfoTable()
self._update_count_lock = threading.Lock()
def _ReadMetadataFromStream(cls, stream):
"""Returns metadata obj from input json stream that implements .read()."""
data = None
file_attr_dict = {}
data =
file_attr_dict = json.loads(data)
except (IOError, ValueError):
_Log('Failed to load metadata:%s' % data)
return None
sha1 = file_attr_dict.get(cls.SHA1_ATTR)
sha256 = file_attr_dict.get(cls.SHA256_ATTR)
size = file_attr_dict.get(cls.SIZE_ATTR)
is_delta = file_attr_dict.get(cls.ISDELTA_ATTR)
metadata_size = file_attr_dict.get(cls.METADATA_SIZE_ATTR)
metadata_hash = file_attr_dict.get(cls.METADATA_HASH_ATTR)
return UpdateMetadata(sha1, sha256, size, is_delta, metadata_size,
def _ReadMetadataFromFile(payload_dir):
"""Returns metadata object from the metadata_file in the payload_dir"""
metadata_file = os.path.join(payload_dir, constants.METADATA_FILE)
if os.path.exists(metadata_file):
metadata_stream = open(metadata_file, 'r')
fcntl.lockf(metadata_stream.fileno(), fcntl.LOCK_SH)
metadata = Autoupdate._ReadMetadataFromStream(metadata_stream)
fcntl.lockf(metadata_stream.fileno(), fcntl.LOCK_UN)
return metadata
def _StoreMetadataToFile(cls, payload_dir, metadata_obj):
"""Stores metadata object into the metadata_file of the payload_dir"""
file_dict = {cls.SHA1_ATTR: metadata_obj.sha1,
cls.SHA256_ATTR: metadata_obj.sha256,
cls.SIZE_ATTR: metadata_obj.size,
cls.ISDELTA_ATTR: metadata_obj.is_delta_format,
cls.METADATA_SIZE_ATTR: metadata_obj.metadata_size,
cls.METADATA_HASH_ATTR: metadata_obj.metadata_hash}
metadata_file = os.path.join(payload_dir, constants.METADATA_FILE)
file_handle = open(metadata_file, 'w')
fcntl.lockf(file_handle.fileno(), fcntl.LOCK_EX)
json.dump(file_dict, file_handle)
fcntl.lockf(file_handle.fileno(), fcntl.LOCK_UN)
def _GetVersionFromDir(image_dir):
"""Returns the version of the image based on the name of the directory."""
latest_version = os.path.basename(image_dir)
parts = latest_version.split('-')
# If we can't get a version number from the directory, default to a high
# number to allow the update to happen
# TODO(phobbs) refactor this.
return parts[1] if len(parts) == 3 else "999999.0.0"
def _CanUpdate(client_version, latest_version):
"""True if the latest_version is greater than the client_version."""
_Log('client version %s latest version %s', client_version, latest_version)
client_tokens = client_version.replace('_', '').split('.')
latest_tokens = latest_version.replace('_', '').split('.')
def _SafeInt(part):
return int(part)
except ValueError:
return part
if len(latest_tokens) == len(client_tokens) == 3:
return map(_SafeInt, latest_tokens) > map(_SafeInt, client_tokens)
# If the directory name isn't a version number, let it pass.
return True
def IsDeltaFormatFile(filename):
with open(filename) as payload_file:
payload = update_payload.Payload(payload_file)
return payload.IsDelta()
except (IOError, update_payload.PayloadError):
# For unit tests we may not have real files, so it's ok to ignore these
# errors.
return False
def GenerateUpdateFile(self, src_image, image_path, output_dir):
"""Generates an update gz given a full path to an image.
src_image: Path to a source image.
image_path: Full path to image.
output_dir: Path to the generated update file.
subprocess.CalledProcessError if the update generator fails to generate a
stateful payload.
update_path = os.path.join(output_dir, constants.UPDATE_FILE)
_Log('Generating update image %s', update_path)
update_command = [
'--image', image_path,
'--out_metadata_hash_file', os.path.join(output_dir,
'--output', update_path,
if src_image:
update_command.extend(['--src_image', src_image])
_Log('Running %s', ' '.join(update_command))
def GenerateStatefulFile(image_path, output_dir):
"""Generates a stateful update payload given a full path to an image.
image_path: Full path to image.
output_dir: Directory for emitting the stateful update payload.
subprocess.CalledProcessError if the update generator fails to generate a
stateful payload.
update_command = [
'--image', image_path,
'--output_dir', output_dir,
_Log('Running %s', ' '.join(update_command))
def FindCachedUpdateImageSubDir(self, src_image, dest_image):
"""Find directory to store a cached update.
Given one, or two images for an update, this finds which cache directory
should hold the update files, even if they don't exist yet.
A directory path for storing a cached update, of the following form:
Non-delta updates:
Delta updates:
update_dir = ''
if src_image:
update_dir += common_util.GetFileMd5(src_image) + '_'
update_dir += common_util.GetFileMd5(dest_image)
return os.path.join(constants.CACHE_DIR, update_dir)
def GenerateUpdateImage(self, image_path, output_dir):
"""Force generates an update payload based on the given image_path.
image_path: full path to the image.
output_dir: the directory to write the update payloads to
AutoupdateError if it failed to generate either update or stateful
_Log('Generating update for image %s', image_path)
# Delete any previous state in this directory.
os.system('rm -rf "%s"' % output_dir)
self.GenerateUpdateFile(self.src_image, image_path, output_dir)
self.GenerateStatefulFile(image_path, output_dir)
except subprocess.CalledProcessError:
os.system('rm -rf "%s"' % output_dir)
raise AutoupdateError('Failed to generate update in %s' % output_dir)
def GenerateUpdateImageWithCache(self, image_path):
"""Force generates an update payload based on the given image_path.
image_path: full path to the image.
update directory relative to static_image_dir.
AutoupdateError if it we need to generate a payload and fail to do so.
_Log('Generating update for src %s image %s', self.src_image, image_path)
# If it was pregenerated, don't regenerate.
if self.pregenerated_path:
return self.pregenerated_path
# Which sub_dir should hold our cached update image.
cache_sub_dir = self.FindCachedUpdateImageSubDir(self.src_image, image_path)
_Log('Caching in sub_dir "%s"', cache_sub_dir)
# The cached payloads exist in a cache dir.
cache_dir = os.path.join(self.static_dir, cache_sub_dir)
cache_update_payload = os.path.join(cache_dir,
cache_stateful_payload = os.path.join(cache_dir,
# Check to see if this cache directory is valid.
if not (os.path.exists(cache_update_payload) and
self.GenerateUpdateImage(image_path, cache_dir)
# Don't regenerate the image for this devserver instance.
self.pregenerated_path = cache_sub_dir
# Generate the cache file.
return cache_sub_dir
def _SymlinkUpdateFiles(self, target_dir, link_dir):
"""Symlinks the update-related files from target_dir to link_dir.
Every time an update is called, clear existing files/symlinks in the
link_dir, and replace them with symlinks to the target_dir.
target_dir: Location of the target files.
link_dir: Directory where the links should exist after.
_Log('Linking %s to %s', target_dir, link_dir)
if link_dir == target_dir:
_Log('Cannot symlink into the same directory.')
for _, _, files in os.walk(target_dir):
for target in files:
link = os.path.join(link_dir, target)
target = os.path.join(target_dir, target)
common_util.SymlinkFile(target, link)
def GetUpdateForLabel(self, client_version, label,
"""Given a label, get an update from the directory.
client_version: Current version of the client or FORCED_UPDATE
label: the relative directory inside the static dir
image_name: If the image type was specified by the update rpc, we try to
find an image with this file name first. This is by default
"chromiumos_test_image.bin" but can also take any of the values in
A relative path to the directory with the update payload.
This is the label if an update did not need to be generated, but can
be label/cache/hashed_dir_for_update.
AutoupdateError: If client version is higher than available update found
at the directory given by the label.
_Log('Update label/file: %s/%s', label, image_name)
static_image_dir = _NonePathJoin(self.static_dir, label)
static_update_path = _NonePathJoin(static_image_dir, constants.UPDATE_FILE)
static_image_path = _NonePathJoin(static_image_dir, image_name)
# Update the client only if client version is older than available update.
latest_version = self._GetVersionFromDir(static_image_dir)
if not (client_version == FORCED_UPDATE or
self._CanUpdate(client_version, latest_version)):
raise AutoupdateError(
'Update check received but no update available for client')
if label and os.path.exists(static_update_path):
# An update payload was found for the given label, return it.
return label
elif os.path.exists(static_image_path) and common_util.IsInsideChroot():
# Image was found for the given label. Generate update if we can.
rel_path = self.GenerateUpdateImageWithCache(static_image_path)
# Add links from the static directory to the update.
cache_path = _NonePathJoin(self.static_dir, rel_path)
self._SymlinkUpdateFiles(cache_path, static_image_dir)
return label
# The label didn't resolve.
return None
def PreGenerateUpdate(self):
"""Pre-generates an update and prints out the relative path it.
Returns relative path of the update.
AutoupdateError if it failed to generate the payload.
_Log('Pre-generating the update payload')
# Does not work with labels so just use static dir. (empty label)
pregenerated_update = self.GetPathToPayload('', FORCED_UPDATE, self.board)
print('PREGENERATED_UPDATE=%s' % _NonePathJoin(pregenerated_update,
return pregenerated_update
def _GetMetadataHash(payload_dir):
"""Gets the metadata hash, if it exists.
payload_dir: The payload directory.
The metadata hash, base-64 encoded or None if there is no metadata hash.
path = os.path.join(payload_dir, constants.METADATA_HASH_FILE)
if os.path.exists(path):
return base64.b64encode(open(path, 'rb').read())
return None
def _GetMetadataSize(payload_filename):
"""Gets the size of the metadata in a payload file.
payload_filename: Path to the payload file.
The size of the payload metadata, as reported in the payload header.
with open(payload_filename) as payload_file:
payload = update_payload.Payload(payload_file)
return payload.metadata_size
except (IOError, update_payload.PayloadError):
# For unit tests we may not have real files, so it's ok to ignore these
# errors.
return 0
def GetLocalPayloadAttrs(self, payload_dir):
"""Returns hashes, size and delta flag of a local update payload.
payload_dir: Path to the directory the payload is in.
A UpdateMetadata object.
filename = os.path.join(payload_dir, constants.UPDATE_FILE)
if not os.path.exists(filename):
raise AutoupdateError('update.gz not present in payload dir %s' %
metadata_obj = Autoupdate._ReadMetadataFromFile(payload_dir)
if not metadata_obj or not (metadata_obj.sha1 and
metadata_obj.sha256 and
sha1 = common_util.GetFileSha1(filename)
sha256 = common_util.GetFileSha256(filename)
size = common_util.GetFileSize(filename)
is_delta_format = self.IsDeltaFormatFile(filename)
metadata_size = self._GetMetadataSize(filename)
metadata_hash = self._GetMetadataHash(payload_dir)
metadata_obj = UpdateMetadata(sha1, sha256, size, is_delta_format,
metadata_size, metadata_hash)
Autoupdate._StoreMetadataToFile(payload_dir, metadata_obj)
return metadata_obj
def _ProcessUpdateComponents(self, app, event):
"""Processes the components of an update request.
app: An app component of an update request.
event: An event component of an update request.
A named tuple containing attributes of the update requests as the
following fields: 'forced_update_label', 'client_version', 'board',
'event_result' and 'event_type'.
# Initialize an empty dictionary for event attributes to log.
log_message = {}
# Determine request IP, strip any IPv6 data for simplicity.
client_ip = cherrypy.request.remote.ip.split(':')[-1]
# Obtain (or init) info object for this client.
curr_host_info = self.host_infos.GetInitHostInfo(client_ip)
client_version = FORCED_UPDATE
board = None
if app:
client_version = app.getAttribute('version')
channel = app.getAttribute('track')
board = (app.hasAttribute('board') and app.getAttribute('board')
or self.GetDefaultBoardID())
# Add attributes to log message
log_message['version'] = client_version
log_message['track'] = channel
log_message['board'] = board
curr_host_info.attrs['last_known_version'] = client_version
event_result = None
event_type = None
if event:
event_result = int(event[0].getAttribute('eventresult'))
event_type = int(event[0].getAttribute('eventtype'))
client_previous_version = (event[0].getAttribute('previousversion')
if event[0].hasAttribute('previousversion')
else None)
# Store attributes to legacy host info structure
curr_host_info.attrs['last_event_status'] = event_result
curr_host_info.attrs['last_event_type'] = event_type
# Add attributes to log message
log_message['event_result'] = event_result
log_message['event_type'] = event_type
if client_previous_version is not None:
log_message['previous_version'] = client_previous_version
# Log host event, if so instructed.
if self.host_log:
UpdateRequestAttrs = collections.namedtuple(
('forced_update_label', 'client_version', 'board', 'event_result',
return UpdateRequestAttrs(
curr_host_info.attrs.pop('forced_update_label', None),
client_version, board, event_result, event_type)
def _CheckOmahaRequest(cls, app):
"""Checks |app| component of Omaha Request for correctly formed data.
common_util.DevServerHTTPError: if any check fails. All 400 error codes to
indicate a bad HTTP request.
if not app:
raise common_util.DevServerHTTPError(
400, 'Missing app component in Omaha Request')
hardware_class = app.getAttribute('hardware_class')
if not hardware_class:
raise common_util.DevServerHTTPError(
400, 'hardware_class is required in Omaha Request')
track = app.getAttribute('track')
if not (track and track.endswith('-channel')):
raise common_util.DevServerHTTPError(
400, 'Omaha requests need a valid update channel')
def GetDevserverUrl(self):
"""Returns the devserver url base."""
x_forwarded_host = cherrypy.request.headers.get('X-Forwarded-Host')
if x_forwarded_host:
hostname = 'http://' + x_forwarded_host
hostname = cherrypy.request.base
return hostname
def GetStaticUrl(self):
"""Returns the static url base that should prefix all payload responses."""
hostname = self.GetDevserverUrl()
static_urlbase = '%s/static' % hostname
# If we have a proxy port, adjust the URL we instruct the client to
# use to go through the proxy.
if self.proxy_port:
static_urlbase = _ChangeUrlPort(static_urlbase, self.proxy_port)
_Log('Using static url base %s', static_urlbase)
_Log('Handling update ping as %s', hostname)
return static_urlbase
def GetPathToPayload(self, label, client_version, board):
"""Find a payload locally.
See devserver's update rpc for documentation.
label: from update request
client_version: from update request
board: from update request
The relative path to an update from the static_dir
AutoupdateError: If the update could not be found.
path_to_payload = None
#TODO(joychen): deprecate --payload flag
if self.payload_path:
# Copy the image from the path to '/forced_payload'
label = 'forced_payload'
dest_path = os.path.join(self.static_dir, label, constants.UPDATE_FILE)
dest_stateful = os.path.join(self.static_dir, label,
dest_meta = os.path.join(self.static_dir, label, constants.METADATA_FILE)
src_path = os.path.abspath(self.payload_path)
src_stateful = os.path.join(os.path.dirname(src_path),
common_util.MkDirP(os.path.join(self.static_dir, label))
common_util.SymlinkFile(src_path, dest_path)
# The old metadata file should be regenerated whenever a new payload is
# used.
except OSError:
if os.path.exists(src_stateful):
# The stateful payload is optional.
common_util.SymlinkFile(src_stateful, dest_stateful)
_Log('WARN: %s not found. Expected for dev and test builds',
if os.path.exists(dest_stateful):
path_to_payload = self.GetUpdateForLabel(client_version, label)
#TODO(joychen): deprecate --image flag
elif self.forced_image:
if self.forced_image.startswith('xbuddy:'):
# This is trying to use an xbuddy path in place of a path to an image.
xbuddy_label = self.forced_image.split(':')[1]
self.forced_image = None
# Make sure the xbuddy path target is in the directory.
path_to_payload, _image_name = self.xbuddy.Get(xbuddy_label.split('/'))
# Pretend to have called update with this update path to payload.
self.GetPathToPayload(xbuddy_label, client_version, board)
src_path = os.path.abspath(self.forced_image)
if os.path.exists(src_path) and common_util.IsInsideChroot():
# Image was found for the given label. Generate update if we can.
path_to_payload = self.GenerateUpdateImageWithCache(src_path)
# Add links from the static directory to the update.
cache_path = _NonePathJoin(self.static_dir, path_to_payload)
self._SymlinkUpdateFiles(cache_path, self.static_dir)
label = label or ''
label_list = label.split('/')
# Suppose that the path follows old protocol of indexing straight
# into static_dir with board/version label.
# Attempt to get the update in that directory, generating if necc.
path_to_payload = self.GetUpdateForLabel(client_version, label)
if path_to_payload is None:
# There was no update or image found in the directory.
# Let XBuddy find an image, and then generate an update to it.
if label_list[0] == 'xbuddy':
# If path explicitly calls xbuddy, pop off the tag.
x_label, image_name = self.xbuddy.Translate(label_list, board=board)
if image_name not in constants.ALL_IMAGES:
raise AutoupdateError(
"Use an image alias: dev, base, test, or recovery.")
# Path has been resolved, try to get the image.
path_to_payload = self.GetUpdateForLabel(client_version, x_label,
if path_to_payload is None:
# Neither image nor update payload found after translation.
# Try to get an update to a test image from GS using the label.
path_to_payload, _image_name = self.xbuddy.Get(
['remote', label, 'full_payload'])
# One of the above options should have gotten us a relative path.
if path_to_payload is None:
raise AutoupdateError('Failed to get an update for: %s' % label)
return path_to_payload
def HandleUpdatePing(self, data, label=''):
"""Handles an update ping from an update client.
data: XML blob from client.
label: optional label for the update.
Update payload message for client.
# Get the static url base that will form that base of our update url e.g.
# http://hostname:8080/static/update.gz.
static_urlbase = self.GetStaticUrl()
# Parse the XML we got into the components we care about.
protocol, app, event, update_check = autoupdate_lib.ParseUpdateRequest(data)
appid = app.getAttribute('appid')
# Process attributes of the update check.
request_attrs = self._ProcessUpdateComponents(app, event)
if not update_check:
if ((request_attrs.event_type ==
request_attrs.event_result == autoupdate_lib.EVENT_RESULT_SUCCESS):
with self._update_count_lock:
if self.max_updates == 0:
_Log('Received too many download_started notifications. This '
'probably means a bug in the test environment, such as too '
'many clients running concurrently. Alternatively, it could '
'be a bug in the update client.')
elif self.max_updates > 0:
self.max_updates -= 1
_Log('A non-update event notification received. Returning an ack.')
return autoupdate_lib.GetEventResponse(protocol, appid)
if request_attrs.forced_update_label:
if label:
_Log('Label: %s set but being overwritten to %s by request', label,
label = request_attrs.forced_update_label
# Make sure that we did not already exceed the max number of allowed update
# responses. Note that the counter is only decremented when the client
# reports an actual download, to avoid race conditions between concurrent
# update requests from the same client due to a timeout.
if self.max_updates == 0:
_Log('Request received but max number of updates already served.')
return autoupdate_lib.GetNoUpdateResponse(protocol, appid)
_Log('Update Check Received. Client is using protocol version: %s',
# Finally its time to generate the omaha response to give to client that
# lets them know where to find the payload and its associated metadata.
metadata_obj = None
path_to_payload = self.GetPathToPayload(
label, request_attrs.client_version, request_attrs.board)
url = _NonePathJoin(static_urlbase, path_to_payload,
local_payload_dir = _NonePathJoin(self.static_dir, path_to_payload)
metadata_obj = self.GetLocalPayloadAttrs(local_payload_dir)
except AutoupdateError as e:
# Raised if we fail to generate an update payload.
_Log('Failed to process an update: %r', e)
return autoupdate_lib.GetNoUpdateResponse(protocol, appid)
# Include public key, if requested.
public_key_data = None
if self.public_key:
public_key_data = base64.b64encode(open(self.public_key, 'r').read())
update_response = autoupdate_lib.GetUpdateResponse(
metadata_obj.sha1, metadata_obj.sha256, metadata_obj.size, url,
metadata_obj.is_delta_format, metadata_obj.metadata_size,
None, public_key_data, protocol, appid,
_Log('Responding to client to use url %s to get image', url)
return update_response
def HandleHostInfoPing(self, ip):
"""Returns host info dictionary for the given IP in JSON format."""
assert ip, 'No ip provided.'
if ip in self.host_infos.table:
return json.dumps(self.host_infos.GetHostInfo(ip).attrs)
def HandleHostLogPing(self, ip):
"""Returns a complete log of events for host in JSON format."""
# If all events requested, return a dictionary of logs keyed by IP address.
if ip == 'all':
return json.dumps(
dict([(key, self.host_infos.table[key].log)
for key in self.host_infos.table]))
# Otherwise we're looking for a specific IP address, so find its log.
if ip in self.host_infos.table:
return json.dumps(self.host_infos.GetHostInfo(ip).log)
# If no events were logged for this IP, return an empty log.
return json.dumps([])
def HandleSetUpdatePing(self, ip, label):
"""Sets forced_update_label for a given host."""
assert ip, 'No ip provided.'
assert label, 'No label provided.'
self.host_infos.GetInitHostInfo(ip).attrs['forced_update_label'] = label