def terminate_machines()

in hostfactory/host_provider/src/cyclecloud_provider.py [0:0]
50 lines of code
9 McCabe index (conditional complexity)

    def terminate_machines(self, input_json, output_handler=None):
        """
        input:
        {
            "machines":[ {"name": "host-123", "machineId": "id-123"} ]
        }
        
        output:
        {
            "message" : "Delete VM success.",
            "requestId" : "delete-i-123",
            "status": "complete"
        }
        """
        output_handler = output_handler or self.stdout_handler
        logger.info("Terminate_machines request for : %s", input_json)         
        request_id = "delete-%s" % str(uuid.uuid4())
        request_id_persisted = False
        try:
            try:
                with self.terminate_json as terminations:
                    machines = {}
                    for machine in input_json["machines"]:
                        if "machineId" not in machine:
                            # cluster api can handle invalid machine ids
                            machine["machineId"] = machine["name"]
                        machines[machine["machineId"]] = machine["name"]
                        
                    terminations[request_id] = {"id": request_id, "machines": machines, "requestTime": calendar.timegm(self.clock())}
                request_id_persisted = True
            except:
                # NOTE: Here we will not exit immediately but exit after an attempted shutdown
                logger.exception("Could not open terminate.json")
            
            request_status = RequestStates.complete
            message = "CycleCloud is terminating the VM(s)"

            try:
                self.cluster.shutdown_nodes(input_json["machines"])
                with self.terminate_json as terminations:
                    terminations[request_id]["terminated"] = True
            except Exception:
                # set to running, we will retry on any status call anyways.
                request_status = RequestStates.running
                message = str(message)
                logger.exception("Could not terminate %s", machines.keys())
            
            logger.info("Terminating %d machine(s): %s", len(machines), ",".join(list(machines.keys())))

            # NOTE: we will still respond with a failure here, but at least we attempted the termination
            if not request_id_persisted:
                return sys.exit(1)
            
            return output_handler.handle({"message": message,
                                "requestId": request_id,
                                "status": request_status,
                                "machines": [ {
                                    "name": machine["name"],
                                    "message": message,
                                    "privateIpAddress": None,
                                    "publicIpAddress": None,
                                    "rcAccount": None,
                                    "requestId": request_id,
                                    "returnId": request_id,
                                    "template": None,
                                    "status": request_status
                                } for machine in input_json["machines"] ]
            })

        except Exception as e:
            logger.exception(str(e))
            if request_id_persisted:
                return output_handler.handle({"status": RequestStates.running, "requestId": request_id})
            return output_handler.handle({"status": RequestStates.complete_with_error, "requestId": request_id, "message": str(e)})