def validate_jamf_pro_version(self, jamf_url, token):
"""return true if Jamf Pro version is 10.35 or greater"""
jamf_pro_version = self.get_jamf_pro_version(jamf_url, token)
if APLooseVersion(jamf_pro_version) >= APLooseVersion("10.35.0"):
return True
else:
return False
def get_latest_version(self, found_filenames):
"""name of folder with the highest version number"""
file_list = found_filenames.split(",")
latest_version = "0"
if len(file_list) > 0:
for item in file_list:
item_version = item.split("/")[0]
if APLooseVersion(item_version) > APLooseVersion(
latest_version):
latest_version = item_version
self.output("Newer version found: %s" % latest_version)
else:
raise ProcessorError("Empty output from SubDirectoryList!")
return latest_version
def main(self):
# Get our list of releases
releases = self.get_releases(self.env["github_repo"])
if self.env.get("sort_by_highest_tag_names"):
releases = sorted(releases,
key=lambda a: APLooseVersion(a["tag_name"]),
reverse=True)
# Store the first eligible asset
self.select_asset(releases, self.env.get("asset_regex"))
# Record the url
self.env["url"] = self.selected_asset["browser_download_url"]
# Get a version string from the tag name
tag = self.selected_release["tag_name"]
# Versioned tags usually start with 'v'
if tag.startswith("v"):
tag = tag.lstrip("v.")
self.env["version"] = tag
# Record release notes
self.env["release_notes"] = self.selected_release["body"]
# The API may return a JSON null if no body text was provided,
# but we cannot ever store a None/NULL in an env.
if not self.env["release_notes"]:
self.env["release_notes"] = ""
def get_latest_version(self, product_matches_list, major_version=""):
"""Find the latest version in the list."""
latest_version = "0"
latest_license = ""
latest_license_file = ""
relevant_filepath = ""
if len(product_matches_list) > 0:
for row in product_matches_list:
product_version_in_list = row[0]
product_path_in_list = row[1]
product_license_key_in_list = row[2]
product_license_file_in_list = row[3]
if product_version_in_list == "":
product_version_in_list = "1"
self.output("Checking version: {}".format(
product_version_in_list)) # GP test
# remove any letters from start of string (thanks EndNote...)
if APLooseVersion(product_version_in_list) > APLooseVersion(
latest_version):
if major_version and not product_version_in_list.startswith(
major_version):
continue
latest_version = product_version_in_list
self.output(
"Newer version found: {}".format(latest_version))
relevant_filepath = product_path_in_list
self.output("Path: {}".format(relevant_filepath))
latest_license = product_license_key_in_list
self.output("License key: {}".format(latest_license))
latest_license_file = product_license_file_in_list
self.output("License file: {}".format(latest_license_file))
else:
self.output("Checking version: {}".format(
product_version_in_list)) # GP test
try:
latest_product_details = [
latest_version,
relevant_filepath,
latest_license,
latest_license_file,
]
except UnboundLocalError:
raise ProcessorError("No new version found!")
else:
raise ProcessorError("Empty output from SubDirectoryList!")
return latest_product_details
def get_reader_dmg_info(self, base_url, language, major_version,
os_version):
"""Returns download URL for Adobe Reader DMG"""
request_url = base_url % (os_version, language)
header = {"x-requested-with": "XMLHttpRequest"}
json_response = self.download(request_url, headers=header)
reader_info = json.loads(json_response)
major_version_string = MAJOR_VERSION_MATCH_STR % major_version
matches = {
item["Version"]: item["download_url"]
for item in reader_info
if major_version_string in item["download_url"]
}
try:
version = max(matches, key=lambda x: APLooseVersion(x))
return matches[version], version
except IndexError:
raise ProcessorError(
"Can't find Adobe Reader download URL for %s, version %s" %
(language, major_version))
def main(self):
# Remove Accept and Authorization form curl options
self.filter_curl_opts()
# load github session
self.github = self.load_github_session()
# Get our list of releases
releases = self.get_releases(self.env["github_repo"])
if self.env.get("sort_by_highest_tag_names"):
releases = sorted(releases,
key=lambda a: APLooseVersion(a["tag_name"]),
reverse=True)
# Store the first eligible asset
self.select_asset(releases, self.env.get("asset_regex"))
# Set env variables
self.env["filename"] = self.selected_asset["name"]
self.env["url"] = self.selected_asset["url"]
self.env["version"] = self.get_tag()
self.env["curl_opts"] = self.get_curl_opts()
self.env["release_notes"] = self.get_release_notes()
def main(self):
"""Get URL for latest version in update feed"""
if "PKG" in self.env:
self.output("Local PKG provided, no downloaded needed.")
self.output("WARNING: Skipping this processor means output "
"variables 'version', 'additional_pkginfo' will "
"not contain useful info. If these are needed "
"in other recipe steps, this may give unexpected "
"results.")
self.env["url"] = self.env.get("PKG")
self.env["additional_pkginfo"] = {}
self.env["version"] = "NotSetBySparkleUpdateInfoProvider"
return
# handle custom xmlns and version attributes
self.xmlns = self.env.get("alternate_xmlns_url", DEFAULT_XMLNS)
data = self.get_feed_data(self.env.get("appcast_url"))
items = self.parse_feed_data(data)
sorted_items = sorted(items,
key=lambda a: APLooseVersion(a["version"]))
latest = sorted_items[-1]
self.output(f"Version retrieved from appcast: {latest['version']}")
if latest.get("human_version"):
self.output(
f"User-facing version retrieved from appcast: {latest['human_version']}"
)
pkginfo = self.handle_pkginfo(latest)
self.env["url"] = latest["url"]
self.env["version"] = latest.get("human_version", latest["version"])
self.output(f"Found URL {self.env['url']}")
self.env["additional_pkginfo"] = pkginfo
def getPackageMetaData(self, pkgitem):
"""
Queries an installer item (.pkg, .mpkg, .dist)
and gets metadata. There are a lot of valid Apple package formats
and this function may not deal with them all equally well.
Standard bundle packages are probably the best understood and documented,
so this code deals with those pretty well.
metadata items include:
installer_item_size: size of the installer item (.dmg, .pkg, etc)
installed_size: size of items that will be installed
RestartAction: will a restart be needed after installation?
name
version
description
receipts: an array of packageids that may be installed
(some may not be installed on some machines)
"""
if not self.hasValidPackageExt(pkgitem):
return {}
# first query /usr/sbin/installer for restartAction
installerinfo = self.getPkgRestartInfo(pkgitem)
# now look for receipt/subpkg info
receiptinfo = self.getReceiptInfo(pkgitem)
name = os.path.split(pkgitem)[1]
shortname = os.path.splitext(name)[0]
metaversion = self.getBundleVersion(pkgitem)
if metaversion == "0.0.0.0.0":
metaversion = self.nameAndVersion(shortname)[1]
highestpkgversion = "0.0"
installedsize = 0
for infoitem in receiptinfo:
if APLooseVersion(
infoitem["version"]) > APLooseVersion(highestpkgversion):
highestpkgversion = infoitem["version"]
if "installed_size" in infoitem:
# note this is in KBytes
installedsize += infoitem["installed_size"]
if metaversion == "0.0.0.0.0":
metaversion = highestpkgversion
elif len(receiptinfo) == 1:
# there is only one package in this item
metaversion = highestpkgversion
elif highestpkgversion.startswith(metaversion):
# for example, highestpkgversion is 2.0.3124.0,
# version in filename is 2.0
metaversion = highestpkgversion
cataloginfo = {}
cataloginfo["name"] = self.nameAndVersion(shortname)[0]
cataloginfo["version"] = metaversion
for key in ("display_name", "RestartAction", "description"):
if key in installerinfo:
cataloginfo[key] = installerinfo[key]
if "installed_size" in installerinfo:
if installerinfo["installed_size"] > 0:
cataloginfo["installed_size"] = installerinfo["installed_size"]
elif installedsize:
cataloginfo["installed_size"] = installedsize
cataloginfo["receipts"] = receiptinfo
if os.path.isfile(pkgitem) and not pkgitem.endswith(".dist"):
# flat packages require 10.5.0+
cataloginfo["minimum_os_version"] = "10.5.0"
return cataloginfo