| """ |
| Distributed Cloud Emulator (dcemulator) |
| (c) 2015 by Manuel Peuster <manuel.peuster@upb.de> |
| """ |
| from mininet.node import Docker |
| from mininet.link import Link |
| import logging |
| |
| LOG = logging.getLogger("dcemulator") |
| LOG.setLevel(logging.DEBUG) |
| |
| |
| DCDPID_BASE = 1000 # start of switch dpid's used for data center switches |
| |
| |
| class EmulatorCompute(Docker): |
| """ |
| Emulator specific compute node class. |
| Inherits from Dockernet's Docker host class. |
| Represents a single container connected to a (logical) |
| data center. |
| We can add emulator specific helper functions to it. |
| """ |
| |
| def __init__( |
| self, name, dimage, **kwargs): |
| self.datacenter = kwargs.get("datacenter") # pointer to current DC |
| self.flavor_name = kwargs.get("flavor_name") |
| LOG.debug("Starting compute instance %r in data center %r" % (name, str(self.datacenter))) |
| # call original Docker.__init__ |
| Docker.__init__(self, name, dimage, **kwargs) |
| |
| def getNetworkStatus(self): |
| """ |
| Helper method to receive information about the virtual networks |
| this compute instance is connected to. |
| """ |
| # format list of tuples (name, Ip, MAC, isUp, status) |
| return [(str(i), i.IP(), i.MAC(), i.isUp(), i.status()) |
| for i in self.intfList()] |
| |
| def getStatus(self): |
| """ |
| Helper method to receive information about this compute instance. |
| """ |
| status = {} |
| status["name"] = self.name |
| status["network"] = self.getNetworkStatus() |
| status["image"] = self.dimage |
| status["cpu_quota"] = self.cpu_quota |
| status["cpu_period"] = self.cpu_period |
| status["cpu_shares"] = self.cpu_shares |
| status["cpuset"] = self.cpuset |
| status["mem_limit"] = self.mem_limit |
| status["memswap_limit"] = self.memswap_limit |
| status["state"] = self.dcli.inspect_container(self.dc)["State"] |
| status["id"] = self.dcli.inspect_container(self.dc)["Id"] |
| status["datacenter"] = (None if self.datacenter is None |
| else self.datacenter.label) |
| return status |
| |
| |
| class Datacenter(object): |
| """ |
| Represents a logical data center to which compute resources |
| (Docker containers) can be added at runtime. |
| |
| Will also implement resource bookkeeping in later versions. |
| """ |
| |
| DC_COUNTER = 1 |
| |
| def __init__(self, label, metadata={}): |
| self.net = None # DCNetwork to which we belong |
| # each node (DC) has a short internal name used by Mininet |
| # this is caused by Mininets naming limitations for swtiches etc. |
| self.name = "dc%d" % Datacenter.DC_COUNTER |
| Datacenter.DC_COUNTER += 1 |
| # use this for user defined names that can be longer than self.name |
| self.label = label |
| # dict to store arbitrary metadata (e.g. latitude and longitude) |
| self.metadata = metadata |
| # first prototype assumes one "bigswitch" per DC |
| self.switch = None |
| # keep track of running containers |
| self.containers = {} |
| # pointer to assigned resource model |
| self._resource_model = None |
| |
| def __repr__(self): |
| return self.label |
| |
| def _get_next_dc_dpid(self): |
| global DCDPID_BASE |
| DCDPID_BASE += 1 |
| return DCDPID_BASE |
| |
| def create(self): |
| """ |
| Each data center is represented by a single switch to which |
| compute resources can be connected at run time. |
| |
| TODO: This will be changed in the future to support multiple networks |
| per data center |
| """ |
| self.switch = self.net.addSwitch( |
| "%s.s1" % self.name, dpid=hex(self._get_next_dc_dpid())[2:]) |
| LOG.debug("created data center switch: %s" % str(self.switch)) |
| |
| def start(self): |
| pass |
| |
| def startCompute(self, name, image=None, command=None, network=None, flavor_name="tiny"): |
| """ |
| Create a new container as compute resource and connect it to this |
| data center. |
| :param name: name (string) |
| :param image: image name (string) |
| :param command: command (string) |
| :param network: networks list({"ip": "10.0.0.254/8"}, {"ip": "11.0.0.254/24"}) |
| :param flavor_name: name of the flavor for this compute container |
| :return: |
| """ |
| assert name is not None |
| # no duplications |
| if name in [c.name for c in self.net.getAllContainers()]: |
| raise Exception("Container with name %s already exists." % name) |
| # set default parameter |
| if image is None: |
| image = "ubuntu" |
| if network is None: |
| network = {} # {"ip": "10.0.0.254/8"} |
| if isinstance(network, dict): |
| network = [network] # if we have only one network, put it in a list |
| if isinstance(network, list): |
| if len(network) < 1: |
| network.append({}) |
| |
| # allocate in resource resource model and compute resource limits for new container |
| cpu_limit = mem_limit = disk_limit = -1 |
| cpu_period = cpu_quota = None |
| if self._resource_model is not None: |
| # call allocate in resource model to calculate resource limit for this container |
| (cpu_limit, mem_limit, disk_limit) = alloc = self._resource_model.allocate(name, flavor_name) |
| LOG.debug("Allocation result: %r" % str(alloc)) |
| # check if we have a cpu_limit given by the used resource model |
| if cpu_limit > 0: |
| # calculate cpu period and quota for CFS |
| # (see: https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt) |
| # TODO consider multi core machines etc! non trivial! |
| # Attention minimum cpu_quota is 1ms (micro) |
| cpu_period = 100000 # lets consider a fixed period of 100000 microseconds for now |
| cpu_quota = cpu_period * cpu_limit # calculate the fraction of cpu time for this container |
| LOG.debug( |
| "CPU limit: cpu_quota = cpu_period * cpu_limit = %f * %f = %f" % (cpu_period, cpu_limit, cpu_quota)) |
| # ATTENTION >= 1000 to avoid a invalid argument system error ... no idea why |
| if cpu_quota < 1000: |
| cpu_quota = 1000 |
| LOG.warning("Increased CPU quota for %d to avoid system error." % name) |
| # TODO add memory and disc limitations |
| # create the container |
| d = self.net.addDocker( |
| "%s" % (name), |
| dimage=image, |
| dcmd=command, |
| datacenter=self, |
| flavor_name=flavor_name, |
| cpu_period=int(cpu_period) if cpu_limit > 0 else None, # set cpu limits if needed |
| cpu_quota=int(cpu_quota) if cpu_limit > 0 else None, |
| ) |
| # connect all given networks |
| for nw in network: |
| # TODO we cannot use TCLink here (see: https://github.com/mpeuster/dockernet/issues/3) |
| self.net.addLink(d, self.switch, params1=nw, cls=Link) |
| # do bookkeeping |
| self.containers[name] = d |
| return d # we might use UUIDs for naming later on |
| |
| def stopCompute(self, name): |
| """ |
| Stop and remove a container from this data center. |
| """ |
| assert name is not None |
| if name not in self.containers: |
| raise Exception("Container with name %s not found." % name) |
| self.net.removeLink( |
| link=None, node1=self.containers[name], node2=self.switch) |
| self.net.removeDocker("%s" % (name)) |
| del self.containers[name] |
| # call resource model and free resources |
| if self._resource_model is not None: |
| self._resource_model.free(name) |
| return True |
| |
| def listCompute(self): |
| """ |
| Return a list of all running containers assigned to this |
| data center. |
| """ |
| return list(self.containers.itervalues()) |
| |
| def getStatus(self): |
| """ |
| Return a dict with status information about this DC. |
| """ |
| return { |
| "label": self.label, |
| "internalname": self.name, |
| "switch": self.switch.name, |
| "n_running_containers": len(self.containers), |
| "metadata": self.metadata |
| } |
| |
| def assignResourceModel(self, rm): |
| """ |
| Assign a resource model to this DC. |
| :param rm: a BaseResourceModel object |
| :return: |
| """ |
| if self._resource_model is not None: |
| raise Exception("There is already an resource model assigned to this DC.") |
| self._resource_model = rm |
| self.net.rm_registrar.register(self, rm) |
| LOG.info("Assigned RM: %r to DC: %r" % (rm, self)) |
| |