containers.py 6.85 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
    def __init__(self, rm):
20
        self.containers = dict()
21 22 23 24
        self.pids = dict()
        self.resourcemanager = rm
        self.nodeos = NodeOSClient()
        self.chrt = ChrtClient()
25 26 27 28 29

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

        Returns the pid of the container or a negative number for errors."""
30 31 32 33 34 35
        container = None
        container_name = None
        containerexistsflag = False
        processes = None
        clientids = None

36 37 38
        manifestfile = request['manifest']
        command = request['file']
        args = request['args']
39 40 41 42 43 44 45 46 47 48
        environ = request['environ']
        ucontainername = request['ucontainername']
        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
        apppreloadlibrary = ''

49 50
        manifest = ImageManifest()
        if not manifest.load(manifestfile):
51
            logger.error("Manifest is invalid")
52
            return None
53

54 55 56 57 58 59 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 112 113 114 115 116 117 118 119
        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"]:
                        argv.append('argo-perf-wrapper')

            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
120 121

        # build context to execute
122 123
        # environ['PATH'] = ("/usr/local/sbin:"
        #                   "/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin")
124
        environ['ARGO_CONTAINER_UUID'] = container_name
125 126 127
        environ['AC_APP_NAME'] = manifest.name
        environ['AC_METADATA_URL'] = "localhost"

128 129
        argv.append(command)
        argv.extend(args)
130

131
        # run my command
132 133 134 135 136 137 138 139 140
        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)
141
        else:
142 143 144 145 146 147 148
            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)
149

150
        return process.pid, container
151 152 153

    def delete(self, uuid):
        """Delete a container and kill all related processes."""
154
        self.nodeos.delete(uuid, kill=True)
155
        self.resourcemanager.update(uuid)
156 157
        c = self.containers[uuid]
        del self.containers[uuid]
158
        map(lambda i: self.pids.pop(c.processes[i].pid, None), c.processes)
159

160 161 162 163
    def kill(self, uuid):
        """Kill all the processes of a container."""
        if uuid in self.containers:
            c = self.containers[uuid]
164
            logger.debug("killing %r:", c)
165
            try:
166
                c.process.proc.terminate()
167 168 169
            except OSError:
                pass

170 171
    def list(self):
        """List the containers in the system."""
172
        return [{'uuid': c.uuid, 'pid': c.process.pid} for c in
173
                self.containers.values()]