def stop_service(self, instance_uuid):
"""
This method stops a running service instance.
- It iterates over all VNFDs, stopping them each
+ It iterates over all VNF instances, stopping them each
and removing them from their data center.
- :return:
+ :param instance_uuid: the uuid of the service instance to be stopped
"""
LOG.info("Stopping service %r" % self.uuid)
# get relevant information
vnf_instances = self.instances[instance_uuid]["vnf_instances"]
for v in vnf_instances:
- self._stop_vnfd(v)
+ self._stop_vnfi(v)
if not GK_STANDALONE_MODE:
# remove placement?
# last step: remove the instance from the list of all instances
del self.instances[instance_uuid]
-
-
-
def _start_vnfd(self, vnfd):
"""
Start a single VNFD of this service
vnfi = target_dc.startCompute(self.vnf_name2docker_name[vnf_name], network=intfs, image=docker_name, flavor_name="small")
return vnfi
- def _stop_vnfd(self, vnfi):
+ def _stop_vnfi(self, vnfi):
"""
- Stop a VNFD specified by its name.
+ Stop a VNF instance.
- :param vnf_name: Name of the vnf to be stopped
- :return:
+ :param vnfi: vnf instance to be stopped
"""
-# if vnf_name not in self.vnfds:
-# raise Exception("VNFD with name %s not found." % vnf_name)
# Find the correct datacenter
status = vnfi.getStatus()
dc = vnfi.datacenter
# stop the vnfi
- LOG.info("Stopping the vnf instance contained in %r ind DC %r" % (status["name"], dc))
+ LOG.info("Stopping the vnf instance contained in %r in DC %r" % (status["name"], dc))
dc.stopCompute(status["name"])
def _get_vnf_instance(self, instance_uuid, name):
if service_uuid in GK.services:
# ok, we have a service uuid, lets start the service
service_instance_uuid = GK.services.get(service_uuid).start_service()
- return {"service_instance_uuid": service_instance_uuid}
+ return {"service_instance_uuid": service_instance_uuid}, 201
return "Service not found", 404
def get(self):
def delete(self):
"""
- Stops a running service specified by its UUID.
-
- :return:
+ Stops a running service specified by its service and instance UUID.
"""
- # try to extract the service UUID from the request
+ # try to extract the service and instance UUID from the request
json_data = request.get_json(force=True)
service_uuid = json_data.get("service_uuid")
- instance_uuid = json_data.get("instance_uuid")
+ instance_uuid = json_data.get("service_instance_uuid")
# try to be fuzzy
if service_uuid is None and len(GK.services) > 0:
if instance_uuid is None and len(GK.services[service_uuid].instances) > 0:
instance_uuid = list(GK.services[service_uuid].instances.iterkeys())[0]
- if service_uuid in GK.services:
- # valid service UUID, stop service
+ if service_uuid in GK.services and instance_uuid in GK.services[service_uuid].instances:
+ # valid service and instance UUID, stop service
GK.services.get(service_uuid).stop_service(instance_uuid)
- return "", 0
+ del GK.services.get(service_uuid).instances[instance_uuid]
+ return
return "Service not found", 404
-class Exit(fr.Resource): # name not final
+class Exit(fr.Resource):
def put(self):
"""
Stop the running Containernet instance regardless of data transmitted
"""
- # First, close the mininet CLI
+ GK.net.stop()
+
+
+def initialize_GK():
+ global GK
+ GK = Gatekeeper()
- # Second, stop the network
- service = GK.services[GK.services.keys[0]]
- network = service.vnfds[service.vnfds.keys[0]].get("dc").net # there should be a cleaner way to find the DCNetwork
- network.stop()
# create a single, global GK object
-GK = Gatekeeper()
+GK = None
+initialize_GK()
# setup Flask
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 512 * 1024 * 1024 # 512 MB max upload
# define endpoints
api.add_resource(Packages, '/packages')
api.add_resource(Instantiations, '/instantiations')
-api.add_resource(Exit, '/emulator/exit') # name not final TODO change it or remove TODO
+api.add_resource(Exit, '/emulator/exit')
+
+
+#def initialize_GK():
+# global GK
+# GK = Gatekeeper()
def start_rest_api(host, port, datacenters=dict()):