linux/scripts/container at multikernel-iommu · multikernel/linux · GitHub

History

executable file

199 lines (164 loc) · 5.86 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

#!/usr/bin/env python3

# SPDX-License-Identifier: GPL-2.0-only

"""Containerized builds"""

import abc

import argparse

import logging

import os

import pathlib

import shutil

import subprocess

import sys

import uuid

class ContainerRuntime(abc.ABC):

"""Base class for a container runtime implementation"""

name = None # Property defined in each implementation class

def __init__(self, args, logger):

self._uid = args.uid or os.getuid()

self._gid = args.gid or args.uid or os.getgid()

self._env_file = args.env_file

self._shell = args.shell

self._logger = logger

@classmethod

def is_present(cls):

"""Determine whether the runtime is present on the system"""

return shutil.which(cls.name) is not None

@abc.abstractmethod

def _do_run(self, image, cmd, container_name):

"""Runtime-specific handler to run a command in a container"""

@abc.abstractmethod

def _do_abort(self, container_name):

"""Runtime-specific handler to abort a running container"""

def run(self, image, cmd):

"""Run a command in a runtime container"""

container_name = str(uuid.uuid4())

self._logger.debug("container: %s", container_name)

try:

return self._do_run(image, cmd, container_name)

except KeyboardInterrupt:

self._logger.error("user aborted")

self._do_abort(container_name)

return 1

class CommonRuntime(ContainerRuntime):

"""Common logic for Docker and Podman"""

def _do_run(self, image, cmd, container_name):

cmdline = [self.name, 'run']

cmdline += self._get_opts(container_name)

cmdline.append(image)

cmdline += cmd

self._logger.debug('command: %s', ' '.join(cmdline))

return subprocess.call(cmdline)

def _get_opts(self, container_name):

opts = [

'--name', container_name,

'--rm',

'--volume', f'{pathlib.Path.cwd()}:/src',

'--workdir', '/src',

]

if self._env_file:

opts += ['--env-file', self._env_file]

if self._shell:

opts += ['--interactive', '--tty']

return opts

def _do_abort(self, container_name):

subprocess.call([self.name, 'kill', container_name])

class DockerRuntime(CommonRuntime):

"""Run a command in a Docker container"""

name = 'docker'

def _get_opts(self, container_name):

return super()._get_opts(container_name) + [

'--user', f'{self._uid}:{self._gid}'

]

class PodmanRuntime(CommonRuntime):

"""Run a command in a Podman container"""

name = 'podman'

def _get_opts(self, container_name):

return super()._get_opts(container_name) + [

'--userns', f'keep-id:uid={self._uid},gid={self._gid}',

]

class Runtimes:

"""List of all supported runtimes"""

runtimes = [PodmanRuntime, DockerRuntime]

@classmethod

def get_names(cls):

"""Get a list of all the runtime names"""

return list(runtime.name for runtime in cls.runtimes)

@classmethod

def get(cls, name):

"""Get a single runtime class matching the given name"""

for runtime in cls.runtimes:

if runtime.name == name:

if not runtime.is_present():

raise ValueError(f"runtime not found: {name}")

return runtime

raise ValueError(f"unknown runtime: {name}")

@classmethod

def find(cls):

"""Find the first runtime present on the system"""

for runtime in cls.runtimes:

if runtime.is_present():

return runtime

raise ValueError("no runtime found")

def _get_logger(verbose):

"""Set up a logger with the appropriate level"""

logger = logging.getLogger('container')

handler = logging.StreamHandler()

handler.setFormatter(logging.Formatter(

fmt='[container {levelname}] {message}', style='{'

))

logger.addHandler(handler)

logger.setLevel(logging.DEBUG if verbose is True else logging.INFO)

return logger

def main(args):

"""Main entry point for the container tool"""

logger = _get_logger(args.verbose)

try:

cls = Runtimes.get(args.runtime) if args.runtime else Runtimes.find()

except ValueError as ex:

logger.error(ex)

return 1

logger.debug("runtime: %s", cls.name)

logger.debug("image: %s", args.image)

return cls(args, logger).run(args.image, args.cmd)

if __name__ == '__main__':

parser = argparse.ArgumentParser(

'container',

description="See the documentation for more details: "

"https://docs.kernel.org/dev-tools/container.html"

)

parser.add_argument(

'-e', '--env-file',

help="Path to an environment file to load in the container."

)

parser.add_argument(

'-g', '--gid',

help="Group ID to use inside the container."

)

parser.add_argument(

'-i', '--image', required=True,

help="Container image name."

)

parser.add_argument(

'-r', '--runtime', choices=Runtimes.get_names(),

help="Container runtime name. If not specified, the first one found "

"on the system will be used i.e. Podman if present, otherwise Docker."

)

parser.add_argument(

'-s', '--shell', action='store_true',

help="Run the container in an interactive shell."

)

parser.add_argument(

'-u', '--uid',

help="User ID to use inside the container. If the -g option is not "

"specified, the user ID will also be set as the group ID."

)

parser.add_argument(

'-v', '--verbose', action='store_true',

help="Enable verbose output."

)

parser.add_argument(

'cmd', nargs='+',

help="Command to run in the container"

)

sys.exit(main(parser.parse_args(sys.argv[1:])))

linux/scripts/container at multikernel-iommu · multikernel/linux · GitHub

Expand file tree

Breadcrumbs

container

Latest commit

History

Breadcrumbs

container

File metadata and controls