1#!/usr/bin/env python3
2#
3# Copyright (c) 2011 Intel, Inc.
4#
5# SPDX-License-Identifier: GPL-2.0-only
6#
7
8__all__ = ['ImagerPlugin', 'SourcePlugin']
9
10import os
11import logging
12import types
13
14from collections import defaultdict
15import importlib
16import importlib.util
17
18from wic import WicError
19from wic.misc import get_bitbake_var
20
21PLUGIN_TYPES = ["imager", "source"]
22
23SCRIPTS_PLUGIN_DIR = ["scripts/lib/wic/plugins", "lib/wic/plugins"]
24
25logger = logging.getLogger('wic')
26
27PLUGINS = defaultdict(dict)
28
29class PluginMgr:
30    _plugin_dirs = []
31
32    @classmethod
33    def get_plugins(cls, ptype):
34        """Get dictionary of <plugin_name>:<class> pairs."""
35        if ptype not in PLUGIN_TYPES:
36            raise WicError('%s is not valid plugin type' % ptype)
37
38        # collect plugin directories
39        if not cls._plugin_dirs:
40            cls._plugin_dirs = [os.path.join(os.path.dirname(__file__), 'plugins')]
41            layers = get_bitbake_var("BBLAYERS") or ''
42            for layer_path in layers.split():
43                for script_plugin_dir in SCRIPTS_PLUGIN_DIR:
44                    path = os.path.join(layer_path, script_plugin_dir)
45                    path = os.path.abspath(os.path.expanduser(path))
46                    if path not in cls._plugin_dirs and os.path.isdir(path):
47                        cls._plugin_dirs.insert(0, path)
48
49        if ptype not in PLUGINS:
50            # load all ptype plugins
51            for pdir in cls._plugin_dirs:
52                ppath = os.path.join(pdir, ptype)
53                if os.path.isdir(ppath):
54                    for fname in os.listdir(ppath):
55                        if fname.endswith('.py'):
56                            mname = fname[:-3]
57                            mpath = os.path.join(ppath, fname)
58                            logger.debug("loading plugin module %s", mpath)
59                            spec = importlib.util.spec_from_file_location(mname, mpath)
60                            module = importlib.util.module_from_spec(spec)
61                            spec.loader.exec_module(module)
62
63        return PLUGINS.get(ptype)
64
65class PluginMeta(type):
66    def __new__(cls, name, bases, attrs):
67        class_type = type.__new__(cls, name, bases, attrs)
68        if 'name' in attrs:
69            PLUGINS[class_type.wic_plugin_type][attrs['name']] = class_type
70
71        return class_type
72
73class ImagerPlugin(metaclass=PluginMeta):
74    wic_plugin_type = "imager"
75
76    def do_create(self):
77        raise WicError("Method %s.do_create is not implemented" %
78                       self.__class__.__name__)
79
80class SourcePlugin(metaclass=PluginMeta):
81    wic_plugin_type = "source"
82    """
83    The methods that can be implemented by --source plugins.
84
85    Any methods not implemented in a subclass inherit these.
86    """
87
88    @classmethod
89    def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir,
90                        bootimg_dir, kernel_dir, native_sysroot):
91        """
92        Called after all partitions have been prepared and assembled into a
93        disk image.  This provides a hook to allow finalization of a
94        disk image e.g. to write an MBR to it.
95        """
96        logger.debug("SourcePlugin: do_install_disk: disk: %s", disk_name)
97
98    @classmethod
99    def do_stage_partition(cls, part, source_params, creator, cr_workdir,
100                           oe_builddir, bootimg_dir, kernel_dir,
101                           native_sysroot):
102        """
103        Special content staging hook called before do_prepare_partition(),
104        normally empty.
105
106        Typically, a partition will just use the passed-in parame e.g
107        straight bootimg_dir, etc, but in some cases, things need to
108        be more tailored e.g. to use a deploy dir + /boot, etc.  This
109        hook allows those files to be staged in a customized fashion.
110        Not that get_bitbake_var() allows you to acces non-standard
111        variables that you might want to use for this.
112        """
113        logger.debug("SourcePlugin: do_stage_partition: part: %s", part)
114
115    @classmethod
116    def do_configure_partition(cls, part, source_params, creator, cr_workdir,
117                               oe_builddir, bootimg_dir, kernel_dir,
118                               native_sysroot):
119        """
120        Called before do_prepare_partition(), typically used to create
121        custom configuration files for a partition, for example
122        syslinux or grub config files.
123        """
124        logger.debug("SourcePlugin: do_configure_partition: part: %s", part)
125
126    @classmethod
127    def do_prepare_partition(cls, part, source_params, creator, cr_workdir,
128                             oe_builddir, bootimg_dir, kernel_dir, rootfs_dir,
129                             native_sysroot):
130        """
131        Called to do the actual content population for a partition i.e. it
132        'prepares' the partition to be incorporated into the image.
133        """
134        logger.debug("SourcePlugin: do_prepare_partition: part: %s", part)
135
136    @classmethod
137    def do_post_partition(cls, part, source_params, creator, cr_workdir,
138                             oe_builddir, bootimg_dir, kernel_dir, rootfs_dir,
139                             native_sysroot):
140        """
141        Called after the partition is created. It is useful to add post
142        operations e.g. security signing the partition.
143        """
144        logger.debug("SourcePlugin: do_post_partition: part: %s", part)
145