'munki_pkginfo_name_suffix': '_Update',

'munki_repo_destination_path': 'apps/Adobe/CC_Updates',

'munkiimport_options': [],

'local_cache_path': os.path.join(SCRIPT_DIR, 'aamcache'),

'munki_tool': 'munkiimport'

# http://ascii-table.com/ansi-escape-sequences.php

BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)

RESET_SEQ = "\033[0m"

COLOR_SEQ = "\033[0;%dm"

COLORS = {'DEBUG': MAGENTA,

'VERBOSE': GREEN,

'INFO': BLUE,

'WARNING': YELLOW,

'ERROR': RED}

LEVELS = {10: 'DEBUG', 20: 'VERBOSE', 30: 'INFO', 40: 'WARNING', 50: 'ERROR'}

def __init__(self, use_color=True, fmt="%(message)s"):

logging.Formatter.__init__(self)

self.use_color = use_color

def format(self, record):

# Code to prepend level name to log message

# if record.levelno != 40:

# message = "%s: %s" % (self.LEVELS[record.levelno], record.getMessage())

# else:

# message = record.getMessage()

# record.message = message

record.message = record.getMessage()

s = self._fmt % record.__dict__

if self.use_color:

if record.levelno != 30:

color = 30 + self.COLORS[self.LEVELS[record.levelno]]

s = self.COLOR_SEQ % color + s + self.RESET_SEQ

p = {}

if os.path.exists(settings_plist):

try:

p = plistlib.readPlist(settings_plist)

except ExpatError:

errorExit(

"Settings plist found at %s, but it could not be parsed!"

% settings_plist)

if name in DEFAULT_PREFS.keys() and not name in p.keys():

value = DEFAULT_PREFS[name]

elif name in p.keys():

value = p[name]

else:

value = None

if pref('aam_server_baseurl'):

return pref('aam_server_baseurl')

urls = ('https://swupdl.adobe.com', 'https://swupmf.adobe.com')

if NONSSL_ADOBE_URL:

urls = ('http://swupdl.adobe.com', 'http://swupmf.adobe.com')

if type == 'updates':

return urls[0]

elif type == 'webfeed':

url = urljoin(getURL(type='webfeed'), 'webfeed/oobe/aam20/%s/updaterfeed.xml' % platform)

try:

opener = urllib.urlopen(url)

except BaseException as e:

L.log(ERROR, "Error reading feed data from URL: %s" % url)

errorExit(e)

xml = opener.read()

opener.close()

search = re.compile("<(.+?)>")

results = re.findall(search, xml)

updates = []

for update in feed_list:

# skip COMBOs (language packs?)

if not update.startswith('COMBO'):

cmpnts = update.split(',')

ver = cmpnts[-1] # version: last

prod = cmpnts[-2] # product: 2nd last

chan = cmpnts[-3] # channel: 3rd last

if cmpnts[0] != "REVOKE":

revoked = False

else:

revoked = True

L.log(DEBUG, "Parsed: Channel: {0}, Product: {1}, Version: {2}, Revoked: {3}".format(

chan, prod, ver, revoked))

updates.append(UpdateMeta(channel=chan, product=prod, version=ver, revoked=revoked, xml=None))

"""Takes a list of product plist objects and returns a dict of

channels and what each is an update_for."""

channels = {}

for product in products:

for channel in product['channels']:

if not channel in channels.keys():

channels[channel] = {}

channels[channel]['munki_update_for'] = []

if 'munki_update_for' in product.keys():

channels[channel]['munki_update_for'].append(product['munki_update_for'])

if 'munki_repo_destination_path' in product.keys():

channels[channel]['munki_repo_destination_path'] = product['munki_repo_destination_path']

if 'makepkginfo_options' in product.keys():

channels[channel]['makepkginfo_options'] = product['makepkginfo_options']

updates = []

for update in parsed_feed:

if update.channel == channel_id:

updates.append(update)

if not len(updates):

updates = None

"""Takes a list of UpdateMeta objects and adds an ElementTree object

with the root of the contents of the update's metadata XML.

Also, when skipTargetLicensingCC is True, remove any updates

with TargetLicensingType of '1'. Further explanation:

TargetLicensingType seems to be 1 for CC updates, 2 for older CS suite updates

Note: These started showing up between when CS6 was released and when

the first suite of new Creative Cloud versions were released a year later.

They seem to be all essentially "point one" minor feature updates versions.

Originally, they seemed to be a limited set of updates for CS6 suite apps that

were only available to CC customers. These updates wouldn't be offered by RUM.

New CC products (ie. Photoshop 14) didn't have this TargetLicensingType.

However, a new set of CC updates released around late August/early

September 2013 have this property and will install with RUM.

At this point, we're skipping them but we need have another mechanism to

properly discern which can be installed.

"""

new_updates = []

for update in updates:

details_url = urljoin(getURL('updates'), UPDATE_PATH_PREFIX + platform) + \

'/%s/%s/%s.xml' % (update.product, update.version, update.version)

try:

channel_xml = urllib.urlopen(details_url)

except BaseException as e:

L.log(DEBUG, "Couldn't read details XML at %s" % details_url)

L.log(DEBUG, e)

continue

try:

details_xml = ET.fromstring(channel_xml.read())

except ET.ParseError as e:

L.log(DEBUG, "Couldn't parse XML: %s" % e)

continue

if skipTargetLicensingCC:

licensing_type_elem = details_xml.find('TargetLicensingType')

if licensing_type_elem is not None:

if licensing_type_elem.text == '1':

L.log(DEBUG, "TargetLicensingType of %s found. This seems to be Creative Cloud updates. "

"Skipping update." % licensing_type_elem.text)

continue

if details_xml is not None:

new_update = UpdateMeta(

channel=update.channel,

product=update.product,

version=update.version,

revoked=update.revoked,

xml=details_xml)

new_updates.append(new_update)

"""Returns True if an update is considered revoked for a channel.

Deduced revocation logic:

An update can be listed multiple times, and both with and without

'REVOKE,[channel]' or 'REVOKE,ALL' lines. It seems an update is

only eligible if it has appeared _more times_ than a line with

REVOKE.

Therefore, to determine whether an update is REVOKE'd, we maintain a

counter and declare it revoked only if there are fewer REVOKE lines

than non-REVOKE lines.

A couple samples of feed entries, in order of appearance in the webfeed,

September 9, 2013, below.

AdobePremiereProCS6-6.0.0-Trial:

- when 6.0.2 was the most recent update being offered, it appeared three

times in the feed, but only once as REVOKE,ALL

- when it was surpassed by 6.0.3, a second REVOKE line was added

curl -s http://swupmf.adobe.com/webfeed/oobe/aam20/mac/updaterfeed.xml | grep AdobePremiereProCS6-6.0.0-Trial

<REVOKE,ALL,AdobePremiereProCS6-6.0.0-Trial,6.0.4>

<AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.5>

<REVOKE,ALL,AdobePremiereProCS6-6.0.0-Trial,6.0.2>

<AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.4>

<AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.2>

<REVOKE,ALL,AdobePremiereProCS6-6.0.0-Trial,6.0.2>

<AdobePremiereProCS6-6.0.0-Trial,AdobeDynamicLinkMediaServer-1.0,1.0.1>

<REVOKE,ALL,AdobePremiereProCS6-6.0.0-Trial,6.0.1>

<AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.2>

<COMBO,AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.2,6.0.2,AdobePremiereProCS6LangPackde_DE-6.0.0,AdobePremiereProCS6LangPacken_US-6.0.0,AdobePremiereProCS6LangPackes_ES-6.0.0,AdobePremiereProCS6LangPackfr_FR-6.0.0,AdobePremiereProCS6LangPackit_IT-6.0.0,AdobePremiereProCS6LangPackja_JP-6.0.0,AdobePremiereProCS6LangPackko_KR-6.0.0>

<AdobePremiereProCS6-6.0.0-Trial,AdobeCSXSInfrastructureCS6-3,3.0.2>

<AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.1>

<COMBO,AdobePremiereProCS6-6.0.0-Trial,AdobePremiereProCS6-6.0.0-Trial,6.0.1,6.0.1,AdobePremiereProCS6LangPackde_DE-6.0.0,AdobePremiereProCS6LangPacken_US-6.0.0,AdobePremiereProCS6LangPackes_ES-6.0.0,AdobePremiereProCS6LangPackfr_FR-6.0.0,AdobePremiereProCS6LangPackit_IT-6.0.0,AdobePremiereProCS6LangPackja_JP-6.0.0,AdobePremiereProCS6LangPackko_KR-6.0.0>

<AdobePremiereProCS6-6.0.0-Trial,AdobeCSXSInfrastructureCS6-3,3.0.1>

PhotoshopCameraRaw764bit-7:

curl -s http://swupmf.adobe.com/webfeed/oobe/aam20/mac/updaterfeed.xml | grep PhotoshopCameraRaw764bit-7.0

<REVOKE,PhotoshopCameraRaw7-7.0,PhotoshopCameraRaw764bit-7.0,7.1.71>

<REVOKE,PhotoshopCameraRaw7-7.0,PhotoshopCameraRaw764bit-7.0,7.2.82>

<PhotoshopCameraRaw7-7.0,PhotoshopCameraRaw764bit-7.0,7.2.82>

<PhotoshopCameraRaw7-7.0,PhotoshopCameraRaw764bit-7.0,7.1.71>

Some revoke-related strings from

Adobe Application\ Manager/UWA/UpdaterCore.framework/Versions/A/UpdaterCore:

Revoke Update: Invalid tracker input.No Recommendation

Revoke Update: Removing whole update as its a REVOKE ALL.

Revoke Update: Invalid tracker input.ChannelID should be uniquely present

Revoke Update: Invalid tracker input.OwningID and UpdateID should be uniquely present

Revoke Update: Removing whole update as this was the last recommentation.

Revoke Update: Removing only this recommentation and not the whole update.

"""

revoke_count = 0

for update in parsed_feed:

if (update.product, update.version) == (product, version) \

and update.channel in [channel, 'ALL']:

if update.revoked == True:

L.log(DEBUG, "REVOKE counter +1")

revoke_count += 1

else:

L.log(DEBUG, "REVOKE counter -1")

revoke_count -= 1

if revoke_count > -1:

return True

else:

"""Given a list of UpdateMeta tuples, return a string of the

highest detected version. We should be able to rely entirely on

the webfeed revoke logic and not use this, but this helps catch

at least one edge case: AdobeCSXSInfrastructureCS6_3

"""

from distutils.version import LooseVersion

def compare_versions(a, b):

"""Internal comparison function for use with sorting"""

return cmp(LooseVersion(a), LooseVersion(b))

versions = []

for update in updates:

if update.product == product:

if not include_revoked and not update.revoked:

versions.append(update.version)

if versions:

versions.sort(compare_versions)

highest = versions[-1]

return highest

else:

plist = {}

channels = []

# If we were given a mounted installer ESD path..

if os.path.isdir(path):

for root, dirs, files in os.walk(path):

if 'payloads' in dirs and 'Install.app' in dirs:

payload_dir = os.path.join(root, 'payloads')

media_db_path = os.path.join(payload_dir, 'Media_db.db')

if os.path.exists(media_db_path):

conn = sqlite3.connect(media_db_path)

c = conn.cursor()

c.execute("""SELECT value from PayloadData where PayloadData.key = 'ChannelID'""")

result = c.fetchall()

c.close()

if result:

channels = [i[0] for i in result]

else:

errorExit("Error: No ChannelIds could be retrieved from the Media_db!")

else:

# fall back to old method of scraping proxy.xml, not compatible with CC products

L.log(WARNING, "Warning: No Media_db.db file found to scrape ChannelIds, "

"falling back to using *.proxy.xml files.")

from glob import glob

proxies = glob(payload_dir + '/*/*.proxy.xml')

for proxy in proxies:

L.log(INFO, "Found %s" % os.path.basename(proxy))

pobj = ET.parse(proxy).getroot()

chan = pobj.find('Channel')

if chan is not None:

channels.append(chan.get('id'))

# or a .ccp file built with CCP?

elif path.endswith('.ccp'):

if zipfile.is_zipfile(path):

with zipfile.ZipFile(path, 'r') as ccp_zip:

try:

path = ccp_zip.open('PkgConfig.xml', 'r')

except KeyError:

errorExit("Couldn't open XML .ccp file at %s/PkgConfig.xml" % path)

id_set = set()

try:

xml = ET.parse(path)

except ET.ParseError:

errorExit("Couldn't parse XML .ccp file at %s" % path)

# XML Structure from which we extract Channel IDs:

# - PackageInfo

# - - PackageHistories

# - - - PackagingHistories

# - - - - InstallInfo

# - - - - - Medias

# - - - - - - Media

# - - - - - - - ProdChannelIDList

# - - - - - - Media

# - - - - - - - ProdChannelIDList

# - - - - - - [etc.]

package_info = xml.getroot()

# there may be multiple PackageHistories elements if a package was created

# from a pre-existing package (<AAMEE_Workflow>MODIFY_EXISTING</AAMEE_Workflow>)

histories = package_info.findall('PackageHistories/PackagingHistory')

if not histories:

errorExit("Unexpected CCP file structure! (Expected 'PackagingHistory' elements")

media_list = []

for hist in histories:

media_list.extend(hist.findall('InstallInfo/Medias/Media'))

for media in media_list:

channel_id_list = media.find('ProdChannelIDList')

if channel_id_list is not None:

for elem in channel_id_list:

id_set.add(elem.text)

channels = sorted(list(id_set))

else:

errorExit("No compatible installer item could be found! See the usage for valid input installer types.")

plist['channels'] = channels

if munki_update_for:

plist['munki_update_for'] = munki_update_for

readsofar = blocknum * blocksize

if totalsize > 0:

percent = readsofar * 1e2 / totalsize

s = "\r%5.1f%% %*d / %d" % (

percent, len(str(totalsize)), readsofar, totalsize)

sys.stderr.write(s)

if readsofar >= totalsize: # near the end

sys.stderr.write("\n")

else: # total size is unknown

usage = """

%prog [options] path/to/plist [path/to/more/plists..]

%prog --build-product-plist [path/to/CCP/pkg/file.ccp] [--munki-update-for BaseProductPkginfoName]

The first form will check and cache updates for the channels listed in the product plists

given as arguments.

The second form will generate a product plist containing all channel IDs contained in the

installer metadata. Accepts either a path to a .cpp file (from Creative Cloud Packager) or

a mounted ESD volume path for CS6-and-earlier installers.

See %prog --help for more options and the README for more detail."""

o = optparse.OptionParser(usage=usage)

o.add_option("-l", "--platform", type='choice', choices=['mac', 'win'], default='mac',

help="Download Adobe updates for Mac or Windows. Available options are 'mac' or 'win', defaults to 'mac'.")

o.add_option("-m", "--munkiimport", action="store_true", default=False,

help="Process downloaded updates with munkiimport using options defined in %s." % os.path.basename(settings_plist))

o.add_option("-r", "--include-revoked", action="store_true", default=False,

help="Include updates that have been marked as revoked in Adobe's feed XML.")

o.add_option("--skip-cc", action="store_true", default=False,

help=("Skip updates for Creative Cloud updates. Useful for certain updates for "

"CS-era applications that incorporate CC subscription updates."))

o.add_option("-f", "--force-import", action="store_true", default=False,

help="Run munkiimport even if it finds an identical pkginfo and installer_item_hash in the repo.")

o.add_option("-c", "--make-catalogs", action="store_true", default=False,

help="Automatically run makecatalogs after importing into Munki.")

o.add_option("-p", "--product-plist", "--plist", action="append", default=[],

help="Deprecated option for specifying product plists, kept for compatibility. Instead, pass plist paths \

as arguments.")

o.add_option("-b", "--build-product-plist", action="store",

help="Given a path to either a mounted Adobe product ESD installer or a .ccp file from a package built with CCP, \

save a product plist containing every Channel ID found for the product. Plist is saved to the current working directory.")

o.add_option("-u", "--munki-update-for", action="store",

help="To be used with the --build-product-plist option, specifies the base Munki product.")

o.add_option("-v", "--verbose", action="count", default=0,

help="Output verbosity. Can be specified either '-v' or '-vv'.")

o.add_option("--no-colors", action="store_true", default=False,

help="Disable colored ANSI output.")

o.add_option("--no-progressbar", action="store_true", default=False,

help="Disable the progress indicator.")

opts, args = o.parse_args()

# setup logging

global L

L = logging.getLogger('com.github.aamporter')

log_stdout_handler = logging.StreamHandler(stream=sys.stdout)

log_stdout_handler.setFormatter(ColorFormatter(

use_color=not opts.no_colors))

L.addHandler(log_stdout_handler)

# INFO is level 30, so each verbose option count lowers level by 10

L.setLevel(INFO - (10 * opts.verbose))

# arg/opt processing

if len(sys.argv) == 1:

o.print_usage()

sys.exit(0)

# any args we just pass through to the "legacy" --product-plist/--plist options

if args:

opts.product_plist.extend(args)

if opts.munki_update_for and not opts.build_product_plist:

errorExit("--munki-update-for requires the --build-product-plist option!")

if not opts.build_product_plist and not opts.product_plist:

errorExit("One of --product-plist or --build-product-plist must be specified!")

if opts.platform == 'win' and opts.munkiimport:

errorExit("Cannot use the --munkiimport option with --platform win option!")

if opts.build_product_plist:

esd_path = opts.build_product_plist

if esd_path.endswith('/'):

esd_path = esd_path[0:-1]

plist = buildProductPlist(esd_path, opts.munki_update_for)

if not plist:

errorExit("Couldn't build payloads from path %s." % esd_path)

else:

if opts.munki_update_for:

output_plist_name = opts.munki_update_for

else:

output_plist_name = os.path.basename(esd_path.replace(' ', ''))

output_plist_name += '.plist'

output_plist_file = os.path.join(os.getcwd(), output_plist_name)

if os.path.exists(output_plist_file):

errorExit("A file already exists at %s, not going to overwrite." %

output_plist_file)

try:

plistlib.writePlist(plist, output_plist_file)

except:

errorExit("Error writing plist to %s" % output_plist_file)

print "Product plist written to %s" % output_plist_file

sys.exit(0)

# munki sanity checks

if opts.munkiimport:

if not os.path.exists('/usr/local/munki'):

errorExit("No Munki installation could be found. Get it at http://code.google.com/p/munki")

sys.path.insert(0, MUNKI_DIR)

munkiimport_prefs = os.path.expanduser('~/Library/Preferences/com.googlecode.munki.munkiimport.plist')

if pref('munki_tool') == 'munkiimport':

if not os.path.exists(munkiimport_prefs):

errorExit("Your Munki repo seems to not be configured. Run munkiimport --configure first.")

try:

import imp

# munkiimport doesn't end in .py, so we use imp to make it available to the import system

imp.load_source('munkiimport', os.path.join(MUNKI_DIR, 'munkiimport'))

import munkiimport

munkiimport.REPO_PATH = munkiimport.pref('repo_path')

except ImportError:

errorExit("There was an error importing munkilib, which is needed for --munkiimport functionality.")

# rewrite some of munkiimport's function names since they were changed to

# snake case around 2.6.1:

# https://github.com/munki/munki/commit/e3948104e869a6a5eb6b440559f4c57144922e71

try:

munkiimport.repoAvailable()

except AttributeError:

munkiimport.repoAvailable = munkiimport.repo_available

munkiimport.makePkgInfo = munkiimport.make_pkginfo

munkiimport.findMatchingPkginfo = munkiimport.find_matching_pkginfo

munkiimport.makeCatalogs = munkiimport.make_catalogs

if not munkiimport.repoAvailable():

errorExit("The Munki repo cannot be located. This tool is not interactive; first ensure the repo is mounted.")

# set up the cache path

local_cache_path = pref('local_cache_path')

if os.path.exists(local_cache_path) and not os.path.isdir(local_cache_path):

errorExit("Local cache path %s was specified and exists, but it is not a directory!" %

local_cache_path)

elif not os.path.exists(local_cache_path):

try:

os.mkdir(local_cache_path)

except OSError:

errorExit("Local cache path %s could not be created. Verify permissions." %

local_cache_path)

except:

errorExit("Unknown error creating local cache path %s." % local_cache_path)

try:

os.access(local_cache_path, os.W_OK)

except:

errorExit("Cannot write to local cache path!" % local_cache_path)

# load our product plists

product_plists = []

for plist_path in opts.product_plist:

try:

plist = plistlib.readPlist(plist_path)

except:

errorExit("Couldn't read plist at %s!" % plist_path)

if 'channels' not in plist.keys():

errorExit("Plist at %s is missing a 'channels' array, which is required." % plist_path)

else:

product_plists.append(plist)

# sanity-check the settings plist for unknown keys

if os.path.exists(settings_plist):

try:

app_options = plistlib.readPlist(settings_plist)

except:

errorExit("There was an error loading the settings plist at %s" % settings_plist)

for k in app_options.keys():

if k not in supported_settings_keys:

print "Warning: Unknown setting in %s: %s" % (os.path.basename(settings_plist), k)

L.log(INFO, "Starting aamporter run..")

if opts.munkiimport:

L.log(INFO, "Will import into Munki (--munkiimport option given).")

L.log(DEBUG, "aamporter preferences:")

for key in supported_settings_keys:

L.log(DEBUG, " - {0}: {1}".format(key, pref(key)))

if (sys.version_info.minor, sys.version_info.micro) == (7, 10):

global NONSSL_ADOBE_URL

NONSSL_ADOBE_URL = True

L.log(VERBOSE, ("Python 2.7.10 detected, using HTTP feed URLs to work "

"around SSL issues."))

# pull feed info and populate channels

L.log(INFO, "Retrieving feed data..")

feed = getFeedData(opts.platform)

parsed = parseFeedData(feed)

channels = getChannelsFromProductPlists(product_plists)

L.log(INFO, "Processing the following Channel IDs:")

[ L.log(INFO, " - %s" % channel) for channel in sorted(channels) ]

# begin caching run and build updates dictionary with product/version info

updates = {}

for channelid in channels.keys():

L.log(VERBOSE, "Getting updates for Channel ID %s.." % channelid)

channel_updates = getUpdatesForChannel(channelid, parsed)

if not channel_updates:

L.log(DEBUG, "No updates for channel %s" % channelid)

continue

channel_updates = addUpdatesXML(channel_updates, opts.platform, skipTargetLicensingCC=opts.skip_cc)

for update in channel_updates:

L.log(VERBOSE, "Considering update %s, %s.." % (update.product, update.version))

if opts.include_revoked is False:

highest_version = getHighestVersionOfProduct(channel_updates, update.product)

if update.version != highest_version:

L.log(DEBUG, "%s is not the highest version available (%s) for this update. Skipping.." % (

update.version, highest_version))

continue

if updateIsRevoked(update.channel, update.product, update.version, parsed):

L.log(DEBUG, "Update is revoked. Skipping update.")

continue

file_element = update.xml.find('InstallFiles/File')

if file_element is None:

L.log(DEBUG, "No File XML element found. Skipping update.")

else:

filename = file_element.find('Name').text

update_bytes = file_element.find('Size').text

description = update.xml.find('Description/en_US').text

display_name = update.xml.find('DisplayName/en_US').text

if not update.product in updates.keys():

updates[update.product] = {}

if not update.version in updates[update.product].keys():

updates[update.product][update.version] = {}

updates[update.product][update.version]['channel_ids'] = []

updates[update.product][update.version]['update_for'] = []

updates[update.product][update.version]['channel_ids'].append(update.channel)

for opt in ['munki_repo_destination_path',

'munki_update_for',

'makepkginfo_options']:

if opt in channels[update.channel].keys():

updates[update.product][update.version][opt] = channels[update.channel][opt]

updates[update.product][update.version]['description'] = description

updates[update.product][update.version]['display_name'] = display_name

dmg_url = urljoin(getURL('updates'), UPDATE_PATH_PREFIX + opts.platform) + \

'/%s/%s/%s' % (update.product, update.version, filename)

output_filename = os.path.join(local_cache_path, "%s-%s.%s" % (

update.product, update.version, 'dmg' if opts.platform == 'mac' else 'zip'))

updates[update.product][update.version]['local_path'] = output_filename

need_to_dl = True

if os.path.exists(output_filename):

we_have_bytes = os.stat(output_filename).st_size

if we_have_bytes == int(update_bytes):

L.log(INFO, "Skipping download of %s %s, it is already cached."

% (update.product, update.version))

need_to_dl = False

else:

L.log(VERBOSE, "Incomplete download (%s bytes on disk, should be %s), re-starting." % (

we_have_bytes, update_bytes))

if need_to_dl:

L.log(INFO, "Downloading %s %s (%s bytes) to %s" % (update.product, update.version, update_bytes, output_filename))

if opts.no_progressbar:

urllib.urlretrieve(dmg_url, output_filename)

else:

urllib.urlretrieve(dmg_url, output_filename, reporthook)

L.log(INFO, "Done caching updates.")

# begin munkiimport run

if opts.munkiimport:

L.log(INFO, "Beginning Munki imports..")

for (update_name, update_meta) in updates.items():

for (version_name, version_meta) in update_meta.items():

need_to_import = True

item_name = "%s%s" % (update_name.replace('-', '_'),

pref('munki_pkginfo_name_suffix'))

# Do 'exists in repo' checks if we're not forcing imports

if opts.force_import is False and pref("munki_tool") == "munkiimport":

pkginfo = munkiimport.makePkgInfo(['--name',

item_name,

version_meta['local_path']],

False)

# Cribbed from munkiimport

L.log(VERBOSE, "Looking for a matching pkginfo for %s %s.." % (

item_name, version_name))

matchingpkginfo = munkiimport.findMatchingPkginfo(pkginfo)

if matchingpkginfo:

L.log(VERBOSE, "Got a matching pkginfo.")

if ('installer_item_hash' in matchingpkginfo and

matchingpkginfo['installer_item_hash'] ==

pkginfo.get('installer_item_hash')):

need_to_import = False

L.log(INFO,

("We have an exact match for %s %s in the repo. Skipping.." % (

item_name, version_name)))

else:

need_to_import = True

if need_to_import:

munkiimport_opts = pref('munkiimport_options')[:]

if pref("munki_tool") == 'munkiimport':

if 'munki_repo_destination_path' in version_meta.keys():

subdir = version_meta['munki_repo_destination_path']

else:

subdir = pref('munki_repo_destination_path')

munkiimport_opts.append('--subdirectory')

munkiimport_opts.append(subdir)

if not version_meta['munki_update_for']:

L.log(WARNING,

"Warning: {0} does not have an 'update_for' key "

"specified in the product plist!".format(item_name))

update_catalogs = []

else:

# handle case of munki_update_for being either a list or a string

flatten = lambda *n: (e for a in n

for e in (flatten(*a) if isinstance(a, (tuple, list)) else (a,)))

update_catalogs = list(flatten(version_meta['munki_update_for']))

for base_product in update_catalogs:

munkiimport_opts.append('--update_for')

munkiimport_opts.append(base_product)

munkiimport_opts.extend(['--name', item_name,

'--displayname', version_meta['display_name'],

'--description', version_meta['description']])

if 'makepkginfo_options' in version_meta:

L.log(VERBOSE,

"Appending makepkginfo options: %s" %

" ".join(version_meta['makepkginfo_options']))

munkiimport_opts += version_meta['makepkginfo_options']

if pref('munki_tool') == 'munkiimport':

import_cmd = ['/usr/local/munki/munkiimport', '--nointeractive']

elif pref('munki_tool') == 'makepkginfo':

import_cmd = ['/usr/local/munki/makepkginfo']

else:

# TODO: validate this pref earlier

L.log(ERROR, "Not sure what tool you wanted to use; munki_tool should be 'munkiimport' " + \

"or 'makepkginfo' but we got '%s'. Skipping import." % (pref('munki_tool')))

break

# Load our app munkiimport options overrides last

import_cmd += munkiimport_opts

import_cmd.append(version_meta['local_path'])

L.log(INFO, "Importing {0} {1} into Munki. Update for: {2}".format(

item_name, version_name, ', '.join(update_catalogs)))

L.log(VERBOSE, "Calling %s on %s version %s, file %s." % (

pref('munki_tool'),

update_name,

version_name,

version_meta['local_path']))

munkiprocess = subprocess.Popen(import_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# wait for the process to terminate

stdout, stderr = munkiprocess.communicate()

import_retcode = munkiprocess.returncode

if import_retcode:

L.log(ERROR, "munkiimport returned an error. Skipping update..")

else:

if pref('munki_tool') == 'makepkginfo':

plist_path = os.path.splitext(version_meta['local_path'])[0] + ".plist"

with open(plist_path, "w") as plist:

plist.write(stdout)

L.log(INFO, "pkginfo written to %s" % plist_path)

L.log(INFO, "Done Munki imports.")

if opts.make_catalogs: