def check_root_site_manager(tool):
    """2.0.x to 2.1.0 upgrade step checker
    """
    portal = aq_parent(aq_inner(tool))
    try:
        # We have to call setSite to make sure we have a site with a proper
        # acquisition context.
        setSite(portal)
        sm = portal.getSiteManager()
        if sm.utilities.LookupClass != FiveVerifyingAdapterLookup:
            return True
    except ComponentLookupError:
        return True

    for tool_interface in _BAD_UTILITIES:
        try:
            iface = resolve(tool_interface)
        except ImportError:
            continue

        if sm.queryUtility(iface) is not None:
            return True

    for tool_id, tool_interface in _TOOL_UTILITIES:
        tool_obj = getToolByName(portal, tool_id, default=None)
        try:
            iface = resolve(tool_interface)
        except ImportError:
            continue

        if tool_obj is not None and sm.queryUtility(iface) is None:
            return True

    return False

    def getProtobuf(self, protobuf_name):
        """
        Get a protobuf class from the identifier supplied.
        """

        # Initialize mapping of protobuf full name to protobuf class
        if self._protobuf_full_name_to_class is None:
            self._protobuf_full_name_to_class = {}
            for contentType in self._content_types.values():
                try:
                    cls = resolve(contentType.python_class)
                    self._protobuf_full_name_to_class[cls.DESCRIPTOR.full_name] = cls
                except ImportError:
                    log.exception('Failed to resolve protobuf: %s', protobuf_name)

        if protobuf_name in self._protobuf_full_name_to_class:
            cls = self._protobuf_full_name_to_class[protobuf_name]
        else:
            try:
                config = self.getContentType(protobuf_name)
            except KeyError:
                raise SchemaException('Could not find protobuf "%s"' % protobuf_name)

            try:
                cls = resolve(config.python_class)
            except ImportError:
                raise ImportError('Could not find protobuf python class "%s"' % config.python_class)

        return cls

    def setData(self, interfacedata, metadata):
        """
        Sets a list of properties on a object.
        Warning: all currently set properties which are not in the
        properties-list wille be removed!

        @param object:      Plone-Object to set the properties on
        @type object:       Plone-Object
        @param properties:  list of propertes.
                            See ftw.publisher.sender.extractor
                            for format details.
        @param type:        list
        @return:            None
        """
        self.logger.info('Updating interface data (UID %s)' %
                (self.object.UID())
        )

        current_ifaces = set(self.adapted.getDirectlyProvidedNames())
        desired_ifaces = set(interfacedata)

        for iface_dotted in current_ifaces - desired_ifaces:
            iface = resolve(iface_dotted)
            noLongerProvides(self.object, iface)

        for iface_dotted in desired_ifaces - current_ifaces:
            iface = resolve(iface_dotted)
            alsoProvides(self.object, iface)

def register_new_custom_type(type_key, workflow_key, archetype_key):
    """Retrieve (create if needed) a domain interface and model for type_key,
    and register as new entry on TYPE_REGISTER.
    """
    
    # generate custom domain interface
    domain_iface_name = naming.model_interface_name(type_key)
    try:
        domain_iface = resolve("%s.%s" % (INTERFACE_MODULE.__name__, domain_iface_name))
        log.warn("Custom interface ALREADY EXISTS: %s" % (domain_iface))
    except ImportError:
        domain_iface = new_custom_domain_interface(type_key, domain_iface_name)
    
    # generate custom domain_model
    domain_model_name = naming.model_name(type_key)
    try:
        domain_model = resolve("%s.%s" % (MODEL_MODULE.__name__, domain_model_name))
        log.warn("Custom domain model ALREADY EXISTS: %s" % (domain_model))
    except ImportError:
        domain_model = new_custom_domain_model(type_key, domain_iface, archetype_key)
    
    # type_info entry
    ti = TI(workflow_key, domain_iface, domain_model)
    ti.custom = True
    TYPE_REGISTRY.append((type_key, ti))
    
    log.info("Registered custom type [%s]: %s" % (archetype_key, type_key))
    return type_key, ti

def load_modules(app, config):
    # load up builtins and modules
    app.modules = []

    try:
        _modules = [
            m.strip() for
            m in config['aio']['builtin'].strip('').split('\n')
            if m.strip()]
        for m in _modules:
            app.modules.append(resolve(m))
    except KeyError:
        pass

    try:
        _modules = [
            m.strip() for
            m in config['aio']['modules'].strip('').split('\n')
            if m.strip()]
        for m in _modules:
            app.modules.append(resolve(m))
    except KeyError:
        pass

    app.modules = tuple(app.modules)

    def loadPlugins(self):
        log.err("bit.core.plugins: loadPlugins")

        config = getUtility(IConfiguration)
        plugins = config.get("bit", "plugins")

        snippet = "<include package='zope.component' />"
        zcml = zcml_template % snippet
        xmlconfig(StringIO(zcml))

        if isinstance(plugins, str):
            plugins = [plugins]

        for plugin in plugins:
            snippet = "<include package='%s' />" % plugin
            zcml = zcml_template % snippet
            zcml_path = os.path.join(resolve(plugin).__path__[0], "configure.zcml")
            if os.path.exists(zcml_path):
                xmlconfig(StringIO(zcml))

        for plugin in plugins:
            snippet = "<include package='%s' file='meta.zcml' />" % plugin
            zcml = zcml_template % snippet
            zcml_path = os.path.join(resolve(plugin).__path__[0], "meta.zcml")
            if os.path.exists(zcml_path):
                xmlconfig(StringIO(zcml))

        for plugin in plugins:
            snippet = "<include package='%s' file='plugin.zcml' />" % plugin
            zcml = zcml_template % snippet
            zcml_path = os.path.join(resolve(plugin).__path__[0], "plugin.zcml")
            if os.path.exists(zcml_path):
                xmlconfig(StringIO(zcml))

def remove_old_contentleadimage(context, logger=None):
    if logger is None:
        # Called as upgrade step: define our own logger.
        logger = logging.getLogger('cpskin.policy remove_old_contentleadimage')
    portal = api.portal.get()
    sm = portal.getSiteManager()

    utilities = {
            'subscribers': sm.utilities._subscribers[0],
            'adapters': sm.utilities._adapters[0],
            # 'provided': sm.utilities._provided
            }
    util_klass = resolve('plone.browserlayer.interfaces.ILocalBrowserLayerType')
    reg_klass = resolve('collective.contentleadimage.interfaces.ILeadImageSpecific')
    for sm_type in utilities.keys():
        utility_registrations = utilities[sm_type]
        for x in utility_registrations.keys():
            if x.__module__ == util_klass.__module__ and x == util_klass:
                for name, klass in utility_registrations[x].items():
                    found = find_object_or_class(klass, reg_klass)
                    # if found:
                    #     import pdb; pdb.set_trace()
                    if found:
                        if type(utility_registrations[x][name]) in \
                                [list, tuple, set]:
                            regs = list(utility_registrations[x][name])
                            regs.remove(found)
                            logger.info('{0} {1} removed'.format(sm_type, reg_klass))
                            utility_registrations[x][name] = tuple(regs)
                        else:
                            logger.info('{0} removed'.format(name))
                            del utility_registrations[x][name]

        setattr(sm.utilities, '_' + sm_type, [utility_registrations])

def load_object(epstr):
    """Loads the object represented in entry-point syntax by the
    specified string."""
    if ':' in epstr:
        module, attr = epstr.split(':')
        module = resolve(module)
        return getattr(module, attr)
    return resolve(epstr)

def _configure(self=None,
               set_up_packages=(),
               features=('devmode', 'testmode'),
               context=None,
               package=None):

    features = set(features) if features is not None else set()

    # This is normally created by a slug, but tests may not always
    # load the slug
    if os.getenv('DATASERVER_DIR_IS_BUILDOUT'): # pragma: no cover
        features.add('in-buildout')


    # zope.component.globalregistry conveniently adds
    # a zope.testing.cleanup.CleanUp to reset the globalSiteManager
    if context is None and (features or package):
        context = config.ConfigurationMachine()
        context.package = package
        xmlconfig.registerCommonDirectives(context)

    for feature in features:
        context.provideFeature(feature)

    if set_up_packages:
        logger.debug("Configuring %s with features %s", set_up_packages, features)

        for i in set_up_packages:
            __traceback_info__ = (i, self)
            if isinstance(i, tuple):
                filename = i[0]
                package = i[1]
            else:
                filename = 'configure.zcml'
                package = i

            if isinstance(package, six.string_types):
                package = dottedname.resolve(package)

            try:
                context = xmlconfig.file(filename, package=package, context=context)
            except IOError as e:
                # Did we pass in a test module (__name__) and there is no
                # configuration in that package? In that case, we want to
                # configure the parent package for sure
                module_path = getattr(package, '__file__', '')
                if (module_path
                        and 'tests' in module_path
                        and os.path.join(os.path.dirname(module_path), filename) == e.filename):
                    parent_package_name = '.'.join(package.__name__.split('.')[:-2])
                    package = dottedname.resolve(parent_package_name)
                    context = xmlconfig.file(filename, package=package, context=context)
                else: # pragma: no cover
                    raise

    return context

 def unmarshal(self, mkey, func_name, marshalled_args, marshalled_kwargs):
     """Does the reverse operation of ``marshal``
     """
     Marshaller = resolve(mkey)
     marshaller = Marshaller()
     func = resolve(func_name)
     args, kwargs = marshaller.unmarshal(
         *marshalled_args,
         **marshalled_kwargs
     )
     return (func, args, kwargs)

    def __init__(self, logger, data):

        self.input_preparation_list = []
        for plugin_data in data["application_configuration"]["pre_processing"]["plugin_list"]:
            self.input_preparation_list.append(resolve(plugin_data["_class"])(logger, plugin_data))

        self.output_preparation_list = []
        for plugin_data in data["application_configuration"]["post_processing"]["plugin_list"]:
            self.output_preparation_list.append(resolve(plugin_data["_class"])(logger, plugin_data))

        plugin_data = data["application_configuration"]["processing_plugin"]
        self.execution_plugin = resolve(plugin_data["_class"])(logger, plugin_data)

  def __init__(self, logger, data):

    self.input_preparation_list = []
    for plugin_data in data['application_configuration']['pre_processing']['plugin_list']:
      self.input_preparation_list.append(resolve(plugin_data['_class'])(logger, plugin_data))

    self.output_preparation_list = []
    for plugin_data in data['application_configuration']['post_processing']['plugin_list']:
      self.output_preparation_list.append(resolve(plugin_data['_class'])(logger, plugin_data))

    plugin_data = data['application_configuration']['processing_plugin']
    self.execution_plugin = resolve(plugin_data['_class'])(logger, plugin_data)

 def sign(self, schema, usedottedname=False):
     """
     sign the object with the signature of the schema used on it
     """
     if usedottedname:
         if schema.__module__ != '.'.join((PKGNAME, 'schema.generated')):
             if isdottedname(schema.__identifier__):
                 resolve(schema.__identifier__)  # ensure it can be imported
                 self.signature = schema.__identifier__
                 return
     saver = queryUtility(ISchemaSaver)
     #persist serialization of schema, get signature
     self.signature = saver.add(schema)

 def is_operation_valid(self, registry, operation):
     # Check that the operation exists.
     op_info = registry.get(operation)
     if op_info is None:
         logger.error("Operation %r is not defined.", operation)
         return False
     op_function_name = op_info.get("operation")
     try:
         resolve(op_function_name)
     except ImportError:
         logger.error("ImportError for operation %r: %s", operation, op_function_name)
         return False
     return True

    def resolve_plugin_class(self, plugin_name):
        try:
            plugin_class = dottedname.resolve(plugin_name)
        except ImportError as e:
            full_plugin_name = 'replay.plugins.' + plugin_name
            try:
                plugin_class = dottedname.resolve(full_plugin_name)
            except ImportError:
                raise e

        if not (inspect.isclass(plugin_class)
                and issubclass(plugin_class, plugins.Plugin)):
            raise ValueError('{} is not a Plugin'.format(plugin_name))

        return plugin_class

def upgrade_root_site_manager(tool):
    """2.0.x to 2.1.0 upgrade step handler
    """
    logger = logging.getLogger('GenericSetup.upgrade')
    portal = aq_parent(aq_inner(tool))
    try:
        setSite(portal)
        sm = portal.getSiteManager()
        if sm.utilities.LookupClass != FiveVerifyingAdapterLookup:
            sm.__parent__ = aq_base(portal)
            sm.utilities.LookupClass = FiveVerifyingAdapterLookup
            sm.utilities._createLookup()
            sm.utilities.__parent__ = sm
            logger.info('LookupClass replaced.')
        else:
            for tool_interface in _BAD_UTILITIES:
                try:
                    iface = resolve(tool_interface)
                except ImportError:
                    continue

                if sm.queryUtility(iface) is not None:
                    sm.unregisterUtility(provided=iface)
                    logger.info('Unregistered utility for %s' % tool_interface)

            for tool_id, tool_interface in _TOOL_UTILITIES:
                tool_obj = getToolByName(portal, tool_id, default=None)
                try:
                    iface = resolve(tool_interface)
                except ImportError:
                    continue

                if tool_obj is not None and sm.queryUtility(iface) is None:
                    sm.registerUtility(tool_obj, iface)
                    logger.info('Registered %s for interface %s' % (
                                                      tool_id, tool_interface))
            return
    except ComponentLookupError:
        next = find_next_sitemanager(portal)
        if next is None:
            next = base
        name = '/'.join(portal.getPhysicalPath())
        sm = PersistentComponents(name, (next,))
        sm.__parent__ = aq_base(portal)
        portal.setSiteManager(sm)
        logger.info("Site manager '%s' added." % name)
    getMultiAdapter((sm, SetupEnviron()), IBody).body = _COMPONENTS_XML
    logger.info('Utility registrations added.')

 def __get__(self, inst, cls=None):
     global generated
     if inst is None:
         return getObjectSpecification(cls)
     spec = getattr(inst, '__provides__', None)
     if spec is None:
         spec = implementedBy(cls)
     signature = getattr(inst, 'signature', None)
     if signature is None:
         return spec
     if not ismd5hex(signature):
         if not isdottedname(signature):
             return spec
         # not an md5 signature, so perhaps we have a dotted name
         try:
             iface = resolve(signature)
             if not IInterface.providedBy(iface):
                 raise ValueError('Not interface: %s' % signature)
             return Implements(iface, spec)
         except ImportError:
             logger.warning('SignatureAwareDescriptor: '
                            'unabled to resolve interface '
                            '%s by dotted name.')
             return spec
     iface_name = 'I%s' % signature
     dynamic = [getattr(generated, iface_name)]
     dynamic.append(spec)
     spec = Implements(*dynamic)
     return spec

    def includableInfo(self, zcml_to_look_for, result,
                       seen=None, exclude=(), extras=()):
        if seen is None:
            seen = set()

        seen.add(self.context.project_name)

        self.includeReqs(self.context.requires(), zcml_to_look_for, result, seen, exclude)

        for dotted_name in self.dottedNames():
            module = resolve(dotted_name)
            for candidate in zcml_to_look_for:
                candidate_path = os.path.join(
                    os.path.dirname(module.__file__), candidate)
                if os.path.isfile(candidate_path):
                    if dotted_name not in result[candidate]:
                        result[candidate].append(dotted_name)

        for extra in extras:
            seen.add((self.context.project_name, extra))

            try:
                reqs = self.context.requires(extras=(extra,))
            except UnknownExtra:
                return

            if reqs:
                self.includeReqs(reqs, zcml_to_look_for, result, seen, exclude)

 def domain_container( self ):
     if self._container_class:
        return self._container_class
     container_class= resolve( self.container )
     self._container_class = type( "ManagedContainer", ( _ManagedContainer, container_class), dict( container_class.__dict__) )        
     protectLikeUnto( self._container_class, container_class )
     return self._container_class

    def onDiscovery(self, theme, settings, dependenciesSettings):
        res = queryResourceDirectory(THEME_RESOURCE_NAME, theme)
        if res is None:
            return

        directoryName = 'overrides'
        if 'directory' in settings:
            directoryName = settings['directory']

        if res.isDirectory(directoryName):

            layer = getattr(schemata, theme, None)

            if 'layer' in settings:
                layerName = settings['layer']

                try:
                    layer = resolve(layerName)
                except (ImportError, AttributeError,):
                    logger.warn("Could not import %s" % layerName)
                    return

            path = os.path.join(res.directory, directoryName)

            manager = z3c.jbot.metaconfigure.handler(path, layer)
            self.registered[theme] = manager