CliFunction

build-userland

@@ -1,16 +1,19 @@
 #!/usr/bin/env python3
 
 import os
-import platform
 import shlex
-import shutil
-import subprocess
 
 import common
+from shell_helpers import LF
 
-class UserlandComponent(common.Component):
-    def add_parser_arguments(self, parser):
-        parser.add_argument(
+class Main(common.BuildCliFunction):
+    def __init__(self):
+        super().__init__(
+            description='''\
+Build our compiled userland examples.
+'''
+        )
+        self.add_argument(
             '--has-package',
             action='append',
             default=[],
@@ -19,20 +22,19 @@ Indicate that a given package is present in the root filesystem, which
 allows us to build examples that rely on it.
 ''',
         )
-        parser.add_argument(
+        self.add_argument(
             '--host',
-            action='store_true',
             default=False,
             help='''\
 Build the userland programs for the host instead of guest.
 Use the host packaged cross toolchain.
 ''',
         )
-        parser.add_argument(
+        self.add_argument(
             '--make-args',
             default='',
         )
-        parser.add_argument(
+        self.add_argument(
             'targets',
             default=[],
             help='''\
@@ -44,49 +46,44 @@ has the OpenBLAS libraries and headers installed.
             nargs='*',
         )
 
-    def do_build(self, args):
-        build_dir = self.get_build_dir(args)
+    def build(self):
+        build_dir = self.get_build_dir()
         os.makedirs(build_dir, exist_ok=True)
-        if args.host:
+        if self.env['host']:
             allowed_toolchains = ['host']
         else:
             allowed_toolchains = ['buildroot']
-        cc = common.get_toolchain_tool('gcc', allowed_toolchains=allowed_toolchains)
-        cxx = common.get_toolchain_tool('g++', allowed_toolchains=allowed_toolchains)
-        common.run_cmd(
+        cc = self.get_toolchain_tool('gcc', allowed_toolchains=allowed_toolchains)
+        cxx = self.get_toolchain_tool('g++', allowed_toolchains=allowed_toolchains)
+        self.sh.run_cmd(
             (
                 [
-                    'make', common.Newline,
-                    '-j', str(args.nproc), common.Newline,
-                    'ARCH={}'.format(args.arch), common.Newline,
-                    'CCFLAGS_SCRIPT={} {}'.format('-I', common.userland_src_dir), common.Newline,
-                    'COMMON_DIR={}'.format(common.root_dir), common.Newline,
-                    'CC={}'.format(cc), common.Newline,
-                    'CXX={}'.format(cxx), common.Newline,
-                    'PKG_CONFIG={}'.format(common.buildroot_pkg_config), common.Newline,
-                    'STAGING_DIR={}'.format(common.buildroot_staging_dir), common.Newline,
-                    'OUT_DIR={}'.format(build_dir), common.Newline,
+                    'make', LF,
+                    '-j', str(self.env['nproc']), LF,
+                    'ARCH={}'.format(self.env['arch']), LF,
+                    'CCFLAGS_SCRIPT={} {}'.format('-I', self.env['userland_src_dir']), LF,
+                    'COMMON_DIR={}'.format(self.env['root_dir']), LF,
+                    'CC={}'.format(cc), LF,
+                    'CXX={}'.format(cxx), LF,
+                    'PKG_CONFIG={}'.format(self.env['buildroot_pkg_config']), LF,
+                    'STAGING_DIR={}'.format(self.env['buildroot_staging_dir']), LF,
+                    'OUT_DIR={}'.format(build_dir), LF,
                 ] +
-                common.add_newlines(['HAS_{}=y'.format(package.upper()) for package in args.has_package]) +
-                shlex.split(args.make_args) +
-                common.add_newlines([os.path.join(build_dir, os.path.splitext(os.path.split(target)[1])[0]) + common.userland_build_ext for target in args.targets])
+                self.sh.add_newlines(['HAS_{}=y'.format(package.upper()) for package in self.env['has_package']]) +
+                shlex.split(self.env['make_args']) +
+                self.sh.add_newlines([os.path.join(build_dir, os.path.splitext(os.path.split(target)[1])[0]) + self.env['userland_build_ext'] for target in self.env['targets']])
             ),
-            cwd=common.userland_src_dir,
-            extra_paths=[common.ccache_dir],
+            cwd=self.env['userland_src_dir'],
+            extra_paths=[self.env['ccache_dir']],
         )
-        common.copy_dir_if_update_non_recursive(
+        self.sh.copy_dir_if_update_non_recursive(
             srcdir=build_dir,
-            destdir=common.out_rootfs_overlay_dir,
-            filter_ext=common.userland_build_ext,
+            destdir=self.env['out_rootfs_overlay_dir'],
+            filter_ext=self.env['userland_build_ext'],
         )
 
-    def get_argparse_args(self):
-        return {
-            'description': 'Build our compiled userland examples',
-        }
-
-    def get_build_dir(self, args):
-        return common.userland_build_dir
+    def get_build_dir(self):
+        return self.env['userland_build_dir']
 
 if __name__ == '__main__':
-    UserlandComponent().build()
+    Main().cli()