def mount(storage=None, name='', storage_parameters=None,
          unsecure=None, extra_root=None):
    """
    Mount a new storage.

    Args:
        storage (str): Storage name.
        name (str): File URL. If storage is not specified,
            URL scheme will be used as storage value.
        storage_parameters (dict): Storage configuration parameters.
            Generally, client configuration and credentials.
        unsecure (bool): If True, disables TLS/SSL to improves
            transfer performance. But makes connection unsecure.
            Default to False.
        extra_root (str): Extra root that can be used in
            replacement of root in path. This can be used to
            provides support for shorter URLS.
            Example: with root "https://www.mycloud.com/user"
            and extra_root "mycloud://" it is possible to access object
            using "mycloud://container/object" instead of
            "https://www.mycloud.com/user/container/object".

    Returns:
        dict: keys are mounted storage, values are dicts of storage information.
    """
    # Tries to infer storage from name
    if storage is None:
        if '://' in name:
            storage = name.split('://', 1)[0].lower()
            # Alias HTTPS to HTTP
            storage = 'http' if storage == 'https' else storage
        else:
            raise ValueError(
                'No storage specified and unable to infer it from file name.')

    # Saves get_storage_parameters
    system_parameters = _system_parameters(
        unsecure=unsecure, storage_parameters=storage_parameters)
    storage_info = dict(storage=storage, system_parameters=system_parameters)

    # Finds module containing target subclass
    for package in STORAGE_PACKAGE:
        try:
            module = import_module('%s.%s' % (package, storage))
            break
        except ImportError:
            continue
    else:
        raise ImportError('No storage named "%s" found' % storage)

    # Case module is a mount redirection to mount multiple storage at once
    if hasattr(module, 'MOUNT_REDIRECT'):
        if extra_root:
            raise ValueError(
                ("Can't define extra_root with %s. "
                 "%s can't have a common root.") % (
                    storage, ', '.join(extra_root)))
        result = dict()
        for storage in getattr(module, 'MOUNT_REDIRECT'):
            result[storage] = mount(
                storage=storage, storage_parameters=storage_parameters,
                unsecure=unsecure)
        return result

    # Finds storage subclass
    classes_items = tuple(_BASE_CLASSES.items())
    for member_name in dir(module):
        member = getattr(module, member_name)
        for cls_name, cls in classes_items:

            # Skip if not subclass of the target class
            try:
                if not issubclass(member, cls) or member is cls:
                    continue
            except TypeError:
                continue

            # The class may have been flag as default or not-default
            default_flag = '_%s__DEFAULT_CLASS' % member.__name__.strip('_')
            try:
                is_default = getattr(member, default_flag)
            except AttributeError:
                is_default = None

            # Skip if explicitly flagged as non default
            if is_default is False:
                continue

            # Skip if is an abstract class not explicitly flagged as default
            elif is_default is not True and member.__abstractmethods__:
                continue

            # Is the default class
            storage_info[cls_name] = member
            break

    # Caches a system instance
    storage_info['system_cached'] = storage_info['system'](**system_parameters)

    # Gets roots
    roots = storage_info['system_cached'].roots

    # Adds extra root
    if extra_root:
        roots = list(roots)
        roots.append(extra_root)
        roots = tuple(roots)
    storage_info['system_cached'].roots = storage_info['roots'] = roots

    # Mounts
    with _MOUNT_LOCK:
        for root in roots:
            MOUNTED[root] = storage_info

        # Reorder to have correct lookup
        items = OrderedDict(
            (key, MOUNTED[key]) for key in reversed(
                sorted(MOUNTED, key=_compare_root)))
        MOUNTED.clear()
        MOUNTED.update(items)

    return {storage: storage_info}
Mount a new storage.

    Args:
        storage (str): Storage name.
        name (str): File URL. If storage is not specified,
            URL scheme will be used as storage value.
        storage_parameters (dict): Storage configuration parameters.
            Generally, client configuration and credentials.
        unsecure (bool): If True, disables TLS/SSL to improves
            transfer performance. But makes connection unsecure.
            Default to False.
        extra_root (str): Extra root that can be used in
            replacement of root in path. This can be used to
            provides support for shorter URLS.
            Example: with root "https://www.mycloud.com/user"
            and extra_root "mycloud://" it is possible to access object
            using "mycloud://container/object" instead of
            "https://www.mycloud.com/user/container/object".

    Returns:
        dict: keys are mounted storage, values are dicts of storage information.