X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=src%2Femuvim%2Fapi%2Fsonata%2Fdummygatekeeper.py;h=68031e494fa71fa4e0ce636a26423ce48ea6d6fb;hb=3444ae45d2b2819993cd972ffe6a572b61fce621;hp=71fb559c3578c3be32939eb0a8fd61f418541582;hpb=bea873776a074bb64c510d8cf6ab4b21ccc3e591;p=osm%2Fvim-emu.git diff --git a/src/emuvim/api/sonata/dummygatekeeper.py b/src/emuvim/api/sonata/dummygatekeeper.py index 71fb559..68031e4 100644 --- a/src/emuvim/api/sonata/dummygatekeeper.py +++ b/src/emuvim/api/sonata/dummygatekeeper.py @@ -28,7 +28,8 @@ class Gatekeeper(object): def __init__(self): self.services = dict() - self.dcs = list() + self.dcs = dict() + self.vnf_counter = 0 # used to generate short names for VNFs (Mininet limitation) LOG.info("Create SONATA dummy gatekeeper.") def register_service_package(self, service_uuid, service): @@ -41,6 +42,10 @@ class Gatekeeper(object): # lets perform all steps needed to onboard the service service.onboard() + def get_next_vnf_name(self): + self.vnf_counter += 1 + return "sonvnf%d" % self.vnf_counter + class Service(object): """ @@ -63,19 +68,6 @@ class Service(object): self.local_docker_files = dict() self.instances = dict() - def start_service(self): - # TODO implement method - instance_uuid = str(uuid.uuid4()) - # 1. parse descriptors and get name of each docker container - for vnfd in self.vnfds.itervalues(): - for u in vnfd.get("virtual_deployment_units"): - docker_name = u.get("vm_image") - # 2. do the corresponding dc.startCompute(name="foobar") calls - print "start %r" % docker_name - print "available dcs: %r " % GK.dcs - # 3. store references to the compute objects in self.instantiations - return instance_uuid - def onboard(self): """ Do all steps to prepare this service to be instantiated @@ -94,6 +86,42 @@ class Service(object): LOG.info("On-boarded service: %r" % self.manifest.get("package_name")) + def start_service(self): + """ + This methods creates and starts a new service instance. + It computes placements, iterates over all VNFDs, and starts + each VNFD as a Docker container in the data center selected + by the placement algorithm. + :return: + """ + LOG.info("Starting service %r" % self.uuid) + # 1. each service instance gets a new uuid to identify it + instance_uuid = str(uuid.uuid4()) + # build a instances dict (a bit like a NSR :)) + self.instances[instance_uuid] = dict() + self.instances[instance_uuid]["vnf_instances"] = list() + # 2. compute placement of this service instance (adds DC names to VNFDs) + self._calculate_placement(FirstDcPlacement) + # iterate over all vnfds that we have to start + for vnfd in self.vnfds.itervalues(): + # iterate over all deployment units within each VNFDs + for u in vnfd.get("virtual_deployment_units"): + # 3. get the name of the docker image to start and the assigned DC + docker_name = u.get("vm_image") + target_dc = vnfd.get("dc") + # 4. perform some checks to ensure we can start the container + assert(docker_name is not None) + assert(target_dc is not None) + if not self._check_docker_image_exists(docker_name): + raise Exception("Docker image %r not found. Abort." % docker_name) + # 5. do the dc.startCompute(name="foobar") call to run the container + # TODO consider flavors, and other annotations + vnfi = target_dc.startCompute(GK.get_next_vnf_name(), image=docker_name, flavor_name="small") + # 6. store references to the compute objects in self.instances + self.instances[instance_uuid]["vnf_instances"].append(vnfi) + LOG.info("Service started. Instance id: %r" % instance_uuid) + return instance_uuid + def _unpack_service_package(self): """ unzip *.son file and store contents in CATALOG_FOLDER/services// @@ -170,6 +198,40 @@ class Service(object): # TODO implement pass + def _check_docker_image_exists(self, image_name): + # TODO implement + return True + + def _calculate_placement(self, algorithm): + """ + Do placement by adding the a field "dc" to + each VNFD that points to one of our + data center objects known to the gatekeeper. + """ + assert(len(self.vnfds) > 0) + assert(len(GK.dcs) > 0) + # instantiate algorithm an place + p = algorithm() + p.place(self.nsd, self.vnfds, GK.dcs) + LOG.info("Using placement algorithm: %r" % p.__class__.__name__) + # lets print the placement result + for name, vnfd in self.vnfds.iteritems(): + LOG.info("Placed VNF %r on DC %r" % (name, str(vnfd.get("dc")))) + + +""" +Some (simple) placement algorithms +""" + + +class FirstDcPlacement(object): + """ + Placement: Always use one and the same data center from the GK.dcs dict. + """ + def place(self, nsd, vnfds, dcs): + for name, vnfd in vnfds.iteritems(): + vnfd["dc"] = list(dcs.itervalues())[0] + """ Resource definitions and API endpoints @@ -226,9 +288,7 @@ class Instantiations(fr.Resource): json_data = request.get_json(force=True) service_uuid = list(GK.services.iterkeys())[0] #json_data.get("service_uuid") # TODO only for quick testing if service_uuid in GK.services: - LOG.info("Starting service %r" % service_uuid) service_instance_uuid = GK.services.get(service_uuid).start_service() - LOG.info("Service started. Instance id: %r" % service_instance_uuid) return {"service_instance_uuid": service_instance_uuid} return "Service not found", 404 @@ -252,7 +312,7 @@ api.add_resource(Packages, '/api/packages') api.add_resource(Instantiations, '/api/instantiations') -def start_rest_api(host, port, datacenters=list()): +def start_rest_api(host, port, datacenters=dict()): GK.dcs = datacenters # start the Flask server (not the best performance but ok for our use case) app.run(host=host,