containers.py 7.33 KB
Newer Older
1 2 3
from __future__ import print_function

from aci import ImageManifest
4
from collections import namedtuple
5
import logging
6
from subprograms import ChrtClient, NodeOSClient, resources
7
import uuid
8

9
logger = logging.getLogger('nrm')
10
Container = namedtuple('Container', ['uuid', 'manifest', 'resources',
11
                                     'power', 'processes', 'clientids'])
12

13 14 15 16 17 18

class ContainerManager(object):

    """Manages the creation, listing and deletion of containers, using a
    container runtime underneath."""

19 20 21
    def __init__(self, rm,
                 perfwrapper="argo-perf-wrapper",
                 linuxperf="perf",
22 23
                 argo_nodeos_config="argo_nodeos_config",
                 pmpi_lib="/usr/lib/libnrm-pmpi.so"):
24 25 26
        self.linuxperf = linuxperf
        self.perfwrapper = perfwrapper
        self.nodeos = NodeOSClient(argo_nodeos_config=argo_nodeos_config)
27
        self.containers = dict()
28 29 30
        self.pids = dict()
        self.resourcemanager = rm
        self.chrt = ChrtClient()
31
        self.pmpi_lib = pmpi_lib
32 33 34 35 36

    def create(self, request):
        """Create a container according to the request.

        Returns the pid of the container or a negative number for errors."""
37 38 39 40 41 42
        container = None
        container_name = None
        containerexistsflag = False
        processes = None
        clientids = None

43 44 45
        manifestfile = request['manifest']
        command = request['file']
        args = request['args']
46
        environ = request['environ']
47
        ucontainername = request['uuid']
48 49 50 51 52 53
        logger.info("run: manifest file:  %s", manifestfile)
        logger.info("run: command:        %s", command)
        logger.info("run: args:           %r", args)
        logger.info("run: ucontainername: %s", ucontainername)

        # TODO: Application library to load must be set during configuration
54
        apppreloadlibrary = self.pmpi_lib
55

56 57
        manifest = ImageManifest()
        if not manifest.load(manifestfile):
58
            logger.error("Manifest is invalid")
59
            return None
60

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
        if hasattr(manifest.app.isolators, 'scheduler'):
            sched = manifest.app.isolators.scheduler
            argv = self.chrt.getwrappedcmd(sched)
        else:
            argv = []

        # Check if user-specified container exists else create it
        if ucontainername in self.containers:
                container_name = ucontainername
                container = self.containers[ucontainername]
                containerexistsflag = True
                processes = container.processes
                clientids = container.clientids
        else:
            processes = dict()
            clientids = dict()

            if ucontainername:
                container_name = ucontainername
            else:
                # If no user-specified container name create one
                container_name = str(uuid.uuid4())

            # ask the resource manager for resources
            req = resources(int(manifest.app.isolators.container.cpus.value),
                            int(manifest.app.isolators.container.mems.value))
            alloc = self.resourcemanager.schedule(container_name, req)
            logger.info("run: allocation: %r", alloc)

            # create container
            logger.info("creating container %s", container_name)
            self.nodeos.create(container_name, alloc)
            container_resources = dict()
            container_resources['cpus'], container_resources['mems'] = alloc

            # Container power settings
            container_power = dict()
            container_power['profile'] = None
            container_power['policy'] = None
            container_power['damper'] = None
            container_power['slowdown'] = None
            container_power['manager'] = None

            # It would've been better if argo-perf-wrapper wrapped around
            # argo-nodeos-config and not the final command -- that way it would
            # be running outside of the container.  However, because
            # argo-nodeos-config is suid root, perf can't monitor it.
            if hasattr(manifest.app.isolators, 'perfwrapper'):
                manifest_perfwrapper = manifest.app.isolators.perfwrapper
                if hasattr(manifest_perfwrapper, 'enabled'):
                    if manifest_perfwrapper.enabled in ["1", "True"]:
112
                        argv.append(self.perfwrapper)
113 114 115 116 117 118 119 120 121 122 123 124 125 126

            if hasattr(manifest.app.isolators, 'power'):
                if hasattr(manifest.app.isolators.power, 'enabled'):
                        pp = manifest.app.isolators.power
                        if pp.enabled in ["1", "True"]:
                            if pp.profile in ["1", "True"]:
                                container_power['profile'] = dict()
                                container_power['profile']['start'] = dict()
                                container_power['profile']['end'] = dict()
                            if pp.policy != "NONE":
                                container_power['policy'] = pp.policy
                                container_power['damper'] = pp.damper
                                container_power['slowdown'] = pp.slowdown
                                environ['LD_PRELOAD'] = apppreloadlibrary
127 128

        # build context to execute
129 130
        # environ['PATH'] = ("/usr/local/sbin:"
        #                   "/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
131
        environ['ARGO_CONTAINER_UUID'] = container_name
132
        environ['PERF'] = self.linuxperf
133 134 135
        environ['AC_APP_NAME'] = manifest.name
        environ['AC_METADATA_URL'] = "localhost"

136 137
        argv.append(command)
        argv.extend(args)
138

139
        # run my command
140 141 142 143 144 145 146 147 148
        process = self.nodeos.execute(container_name, argv, environ)
        processes[process.pid] = process
        clientids[process.pid] = request['clientid']

        if containerexistsflag:
            container.processes[process.pid] = process
            self.pids[process.pid] = container
            logger.info("Created process %s in container %s", process.pid,
                        container_name)
149
        else:
150 151 152 153 154 155 156
            container = Container(container_name, manifest,
                                  container_resources, container_power,
                                  processes, clientids)
            self.pids[process.pid] = container
            self.containers[container_name] = container
            logger.info("Container %s created and running : %r",
                        container_name, container)
157

158
        return process.pid, container
159 160 161

    def delete(self, uuid):
        """Delete a container and kill all related processes."""
162
        self.nodeos.delete(uuid, kill=True)
163
        self.resourcemanager.update(uuid)
164 165
        c = self.containers[uuid]
        del self.containers[uuid]
166
        map(lambda i: self.pids.pop(c.processes[i].pid, None), c.processes)
167

168 169 170 171
    def kill(self, uuid):
        """Kill all the processes of a container."""
        if uuid in self.containers:
            c = self.containers[uuid]
172
            logger.debug("killing %r:", c)
173 174
            for p in c.processes.values():
                try:
175
                    p.proc.terminate()
176 177
                except OSError:
                    logging.error("OS error: could not terminate process.")
178

179 180
    def list(self):
        """List the containers in the system."""
181 182
        return [{'uuid': c.uuid, 'pid': c.processes.keys()}
                for c in self.containers.values()]