Пример #1
0
    def target_merge_busybox(self):
        env = {}
        use = ''
        if 'USE' in self.env:
            use = self.env['USE']

        if len(self.package_list) == 0:
            use += ' static'
        use += ' make-symlinks'
        env.update(self.env)
        env['USE'] = use
        env['ROOT'] = self.target_root

        cmdline = '%s/inhibitor-run.sh run_emerge --newuse --nodeps sys-apps/busybox' \
                % self.env['INHIBITOR_SCRIPT_ROOT']

        if self.seed:
            util.chroot(
                path        = self.target_root,
                function    = util.cmd,
                fargs       = {'cmdline':cmdline, 'env':env},
                failuref    = self.chroot_failure
            )
            util.chroot(
                path        = self.target_root,
                function    = self.path_sync_callback,
                fargs       = {'src':'/bin/busybox', '_':None},
                failuref    = self.chroot_failure
            )

        else:
            util.cmd( cmdline, env = env )
            self.path_sync_callback('/bin/busybox', None)
Пример #2
0
 def _emerge(self, packages, flags=""):
     util.chroot(
         path=self.target_root,
         function=util.cmd,
         fargs={"cmdline": "%s %s %s" % (self.emerge_cmd, flags, packages), "env": self.env},
         failuref=self.chroot_failure,
     )
Пример #3
0
 def run_scripts(self):
     for script in self.scripts:
         script.install(root=self.target_root)
         util.chroot(
             path=self.target_root,
             function=util.cmd,
             fargs={"cmdline": script.cmdline(), "env": self.env},
             failuref=self.chroot_failure,
         )
Пример #4
0
 def setup_extras(self):
     util.chroot(
         path=self.target_root,
         function=util.cmd,
         fargs={
             "cmdline": "%s/inhibitor-run.sh setup_extras" % (self.env["INHIBITOR_SCRIPT_ROOT"],),
             "env": self.env,
         },
         failuref=self.chroot_failure,
     )
Пример #5
0
 def copy_libs(self):
     for root, _, files in os.walk(self.target_root):
         for f in files:
             src_path = os.path.join( root.replace(self.target_root, ''), f )
             if self.seed:
                 util.chroot(
                     path        = self.target_root,
                     function    = self.path_sync_callback,
                     fargs       = {'src':src_path, '_':None},
                     failuref    = self.chroot_failure
                 )
             else:
                 self.path_sync_callback( src_path, None )
Пример #6
0
    def merge_packages(self):
        cmdline = '%s/inhibitor-run.sh run_emerge --newuse %s' % (
            self.env['INHIBITOR_SCRIPT_ROOT'], ' '.join(self.package_list))

        if self.seed:
            util.chroot(
                path        = self.target_root,
                function    = util.cmd,
                fargs       = {'cmdline':cmdline, 'env':self.env},
                failuref    = self.chroot_failure
            )
        else:
            util.cmd( cmdline, env = self.env )
Пример #7
0
    def merge_kernel(self):
        args = ["--build_name", self.build_name, "--kernel_pkg", "'%s'" % (self.kernel.kernel_pkg,)]

        if self.kernel.has("genkernel"):
            args.extend(["--genkernel", self.kernel.genkernel])
        if self.kernel.has("packages"):
            args.extend(["--packages", self.kernel.packages])

        util.chroot(
            path=self.target_root,
            function=util.cmd,
            fargs={"cmdline": "%s/kernel.sh %s" % (self.env["INHIBITOR_SCRIPT_ROOT"], " ".join(args)), "env": self.env},
            failuref=self.chroot_failure,
        )
Пример #8
0
    def update_init(self):
        emb_root = self.target_root
        if self.seed:
            emb_root = emb_root.pjoin(self.target_root)

        util.mkdir(emb_root.pjoin('etc/rc.d'))

        for initd in glob.iglob('%s/*' % emb_root.pjoin('etc/init.d')):
            int_path = initd.replace(emb_root, '')
            util.dbg('Adding %s to init' % int_path)
            util.chroot(
                path        = emb_root,
                function    = util.cmd,
                fargs       = {
                    'cmdline':  '%s enable' % int_path,
                    'shell':    '/bin/ash'
                },
                failuref    = self.chroot_failure,
            )
Пример #9
0
    def merge_kernel(self):
        args = ['--build_name', self.build_name,
            '--kernel_pkg', '\'%s\'' % (self.kernel.kernel_pkg,)]

        cmdline = '%s/kernel.sh %s' % (
            self.env['INHIBITOR_SCRIPT_ROOT'],
            ' '.join(args) )

        env = {}
        env.update(self.env)
        env['ROOT'] = '/tmp/inhibitor/kernelbuild'

        if self.seed:
            util.mkdir( self.target_root.pjoin(env['ROOT']) )
            util.chroot(
                path        = self.target_root,
                function    = util.cmd,
                fargs       = {'cmdline':cmdline, 'env':env},
                failuref    = self.chroot_failure,
            )

            # Grab any modules or firmware and put them into the embedded root fs.
            for d in ('modules', 'firmware'):
                util.chroot(
                    path        = self.target_root,
                    function    = util.cmd,
                    fargs       = {'cmdline': 'rsync -a --delete-after %s %s/' % (
                                        '/tmp/inhibitor/kernelbuild/lib/%s' % (d,),
                                        self.target_root.pjoin('lib'))},
                    failuref    = self.chroot_failure,
                )

        else:
            util.cmd( cmdline, env )

            # Grab any modules or firmware and put them into the embedded root fs.
            for d in ('modules', 'firmware'):
                util.cmd('rsync -a --delete-after %s %s/' % (
                    '/tmp/inhibitor/kernelbuild/lib/%s' % (d,),
                    self.target_root.pjoin('lib')))
Пример #10
0
    def copy_files(self):
        for min_path in self.files:
            if '*' in min_path:
                if self.seed:
                    files = glob.glob(self.target_root.pjoin(min_path))
                    strip_index = len(self.target_root)
                    for i in range(0, len(files)):
                        files[i] = files[i][strip_index:]
                else:
                    files = glob.glob(min_path)
            else:
                files = [ min_path ]

            for path in files:
                if self.seed:
                    if not os.path.lexists(self.target_root.pjoin(path)):
                        util.warn('Path (%s,%s) does not exist' % (min_path, path))
                        continue
                    util.chroot(
                        path        = self.target_root,
                        function    = util.path_sync,
                        fargs       = {
                            'src':                  path,
                            'targ':                 self.target_root.pjoin(path),
                            'file_copy_callback':   self.path_sync_callback
                        },
                        failuref    = self.chroot_failure
                    )
                else:
                    if not os.path.lexists(path):
                        util.warn('Path %s does not exist' % (min_path,))
                        continue
                    util.path_sync(
                        path,
                        self.target_root.pjoin(path),
                        file_copy_callback = self.path_sync_callback
                    )