Source code
Revision control
Copy as Markdown
Other Tools
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
import binascii
import hashlib
import json
import os
import shutil
import sys
import tempfile
import zipfile
from xml.dom import minidom
import mozfile
from mozlog.unstructured import getLogger
from six import reraise, string_types
_SALT = binascii.hexlify(os.urandom(32))
_TEMPORARY_ADDON_SUFFIX = "@temporary-addon"
# Logger for 'mozprofile.addons' module
module_logger = getLogger(__name__)
class AddonFormatError(Exception):
"""Exception for not well-formed add-on manifest files"""
class AddonManager(object):
"""
Handles all operations regarding addons in a profile including:
installing and cleaning addons
"""
def __init__(self, profile, restore=True):
"""
:param profile: the path to the profile for which we install addons
:param restore: whether to reset to the previous state on instance garbage collection
"""
self.profile = profile
self.restore = restore
# Initialize all class members
self._internal_init()
def _internal_init(self):
"""Internal: Initialize all class members to their default value"""
# Add-ons installed; needed for cleanup
self._addons = []
# Backup folder for already existing addons
self.backup_dir = None
self.installed_addons = []
def __del__(self):
# reset to pre-instance state
if self.restore:
self.clean()
def clean(self):
"""Clean up addons in the profile."""
# Remove all add-ons installed
for addon in self._addons:
# Once we have a proper handling of add-ons we should kill the id
# from self._addons once the add-on is removed. For now lets forget
# about the exception
try:
self.remove_addon(addon)
except IOError:
pass
# restore backups
if self.backup_dir and os.path.isdir(self.backup_dir):
extensions_path = os.path.join(self.profile, "extensions")
for backup in os.listdir(self.backup_dir):
backup_path = os.path.join(self.backup_dir, backup)
shutil.move(backup_path, extensions_path)
if not os.listdir(self.backup_dir):
mozfile.remove(self.backup_dir)
# reset instance variables to defaults
self._internal_init()
def get_addon_path(self, addon_id):
"""Returns the path to the installed add-on
:param addon_id: id of the add-on to retrieve the path from
"""
# By default we should expect add-ons being located under the
# extensions folder.
extensions_path = os.path.join(self.profile, "extensions")
paths = [
os.path.join(extensions_path, addon_id),
os.path.join(extensions_path, addon_id + ".xpi"),
]
for path in paths:
if os.path.exists(path):
return path
raise IOError("Add-on not found: %s" % addon_id)
@classmethod
def is_addon(self, addon_path):
"""
Checks if the given path is a valid addon
:param addon_path: path to the add-on directory or XPI
"""
try:
self.addon_details(addon_path)
return True
except AddonFormatError:
return False
def _install_addon(self, path, unpack=False):
addons = [path]
# if path is not an add-on, try to install all contained add-ons
try:
self.addon_details(path)
except AddonFormatError as e:
module_logger.warning("Could not install %s: %s" % (path, str(e)))
# If the path doesn't exist, then we don't really care, just return
if not os.path.isdir(path):
return
addons = [
os.path.join(path, x)
for x in os.listdir(path)
if self.is_addon(os.path.join(path, x))
]
addons.sort()
# install each addon
for addon in addons:
# determine the addon id
addon_details = self.addon_details(addon)
addon_id = addon_details.get("id")
# if the add-on has to be unpacked force it now
# note: we might want to let Firefox do it in case of addon details
orig_path = None
if os.path.isfile(addon) and (unpack or addon_details["unpack"]):
orig_path = addon
addon = tempfile.mkdtemp()
mozfile.extract(orig_path, addon)
# copy the addon to the profile
extensions_path = os.path.join(self.profile, "extensions")
addon_path = os.path.join(extensions_path, addon_id)
if os.path.isfile(addon):
addon_path += ".xpi"
# move existing xpi file to backup location to restore later
if os.path.exists(addon_path):
self.backup_dir = self.backup_dir or tempfile.mkdtemp()
shutil.move(addon_path, self.backup_dir)
# copy new add-on to the extension folder
if not os.path.exists(extensions_path):
os.makedirs(extensions_path)
shutil.copy(addon, addon_path)
else:
# move existing folder to backup location to restore later
if os.path.exists(addon_path):
self.backup_dir = self.backup_dir or tempfile.mkdtemp()
shutil.move(addon_path, self.backup_dir)
# copy new add-on to the extension folder
shutil.copytree(addon, addon_path, symlinks=True)
# if we had to extract the addon, remove the temporary directory
if orig_path:
mozfile.remove(addon)
addon = orig_path
self._addons.append(addon_id)
self.installed_addons.append(addon)
def install(self, addons, **kwargs):
"""
Installs addons from a filepath or directory of addons in the profile.
:param addons: paths to .xpi or addon directories
:param unpack: whether to unpack unless specified otherwise in the install.rdf
"""
if not addons:
return
# install addon paths
if isinstance(addons, string_types):
addons = [addons]
for addon in set(addons):
self._install_addon(addon, **kwargs)
@classmethod
def _gen_iid(cls, addon_path):
hash = hashlib.sha1(_SALT)
hash.update(addon_path.encode())
return hash.hexdigest() + _TEMPORARY_ADDON_SUFFIX
@classmethod
def addon_details(cls, addon_path):
"""
Returns a dictionary of details about the addon.
:param addon_path: path to the add-on directory or XPI
Returns::
{'id': u'rainbow@colors.org', # id of the addon
'version': u'1.4', # version of the addon
'name': u'Rainbow', # name of the addon
'unpack': False } # whether to unpack the addon
"""
details = {"id": None, "unpack": False, "name": None, "version": None}
def get_namespace_id(doc, url):
attributes = doc.documentElement.attributes
namespace = ""
for i in range(attributes.length):
if attributes.item(i).value == url:
if ":" in attributes.item(i).name:
# If the namespace is not the default one remove 'xlmns:'
namespace = attributes.item(i).name.split(":")[1] + ":"
break
return namespace
def get_text(element):
"""Retrieve the text value of a given node"""
rc = []
for node in element.childNodes:
if node.nodeType == node.TEXT_NODE:
rc.append(node.data)
return "".join(rc).strip()
if not os.path.exists(addon_path):
raise IOError("Add-on path does not exist: %s" % addon_path)
is_webext = False
try:
if zipfile.is_zipfile(addon_path):
with zipfile.ZipFile(addon_path, "r") as compressed_file:
filenames = [f.filename for f in (compressed_file).filelist]
if "install.rdf" in filenames:
manifest = compressed_file.read("install.rdf")
elif "manifest.json" in filenames:
is_webext = True
manifest = compressed_file.read("manifest.json").decode()
manifest = json.loads(manifest)
else:
raise KeyError("No manifest")
elif os.path.isdir(addon_path):
entries = os.listdir(addon_path)
# directories may exist that contain one single XPI. If that's
# the case we need to process it just as we do above.
if len(entries) == 1 and zipfile.is_zipfile(
os.path.join(addon_path, entries[0])
):
with zipfile.ZipFile(
os.path.join(addon_path, entries[0]), "r"
) as compressed_file:
filenames = [f.filename for f in (compressed_file).filelist]
if "install.rdf" in filenames:
manifest = compressed_file.read("install.rdf")
elif "manifest.json" in filenames:
is_webext = True
manifest = compressed_file.read("manifest.json").decode()
manifest = json.loads(manifest)
else:
raise KeyError("No manifest")
# Otherwise, treat is an already unpacked XPI.
else:
try:
with open(os.path.join(addon_path, "install.rdf")) as f:
manifest = f.read()
except IOError:
with open(os.path.join(addon_path, "manifest.json")) as f:
manifest = json.loads(f.read())
is_webext = True
else:
raise IOError(
"Add-on path is neither an XPI nor a directory: %s" % addon_path
)
except (IOError, KeyError) as e:
reraise(AddonFormatError, AddonFormatError(str(e)), sys.exc_info()[2])
if is_webext:
details["version"] = manifest["version"]
details["name"] = manifest["name"]
# metadata.
for location in ("applications", "browser_specific_settings"):
try:
details["id"] = manifest[location]["gecko"]["id"]
break
except KeyError:
pass
if details["id"] is None:
details["id"] = cls._gen_iid(addon_path)
details["unpack"] = False
else:
try:
doc = minidom.parseString(manifest)
# Get the namespaces abbreviations
rdf = get_namespace_id(
)
description = doc.getElementsByTagName(rdf + "Description").item(0)
for entry, value in description.attributes.items():
# Remove the namespace prefix from the tag for comparison
entry = entry.replace(em, "")
if entry in details.keys():
details.update({entry: value})
for node in description.childNodes:
# Remove the namespace prefix from the tag for comparison
entry = node.nodeName.replace(em, "")
if entry in details.keys():
details.update({entry: get_text(node)})
except Exception as e:
reraise(AddonFormatError, AddonFormatError(str(e)), sys.exc_info()[2])
# turn unpack into a true/false value
if isinstance(details["unpack"], string_types):
details["unpack"] = details["unpack"].lower() == "true"
# If no ID is set, the add-on is invalid
if details.get("id") is None and not is_webext:
raise AddonFormatError("Add-on id could not be found.")
return details
def remove_addon(self, addon_id):
"""Remove the add-on as specified by the id
:param addon_id: id of the add-on to be removed
"""
path = self.get_addon_path(addon_id)
mozfile.remove(path)