def delete_host_server(self, host_server_id): """ delete a docker host_server for a hackathon. :param host_server_id: the id of host_server in DB :type host_server_id: Integer :return: ok() if succeeds or this host_server doesn't exist precondition_failed() if there are still some containers running """ DockerHostServer.objects(id=host_server_id).delete() return ok()
def update_host_server(self, args): """ update a docker host_server's information for a hackathon. :param hackathon_id: the id of hackathon in DB :type hackathon_id: Integer :return: ok() if succeed. not_found(...) if fail to update the docker_host's information """ vm = DockerHostServer.objects(id=args.id).first() if vm is None: self.log.warn('delete docker_host fail, not find hostserver_id:' + args.id) return not_found("", "host_server not found") vm.vm_name = args.get("vm_name", vm.vm_name) vm.public_dns = args.get("public_dns", vm.public_dns) vm.public_ip = args.get("public_ip", vm.public_ip) vm.private_ip = args.get("private_ip", vm.private_ip) vm.container_max_count = int(args.get("container_max_count", vm.container_max_count)) vm.public_docker_api_port = int(args.get("public_docker_api_port", vm.public_docker_api_port)) vm.private_docker_api_port = int(args.get("private_docker_api_port", vm.private_docker_api_port)) vm.disabled = args.get("disabled", vm.disabled) if self.docker.ping(vm): vm.state = DockerHostServerStatus.DOCKER_READY else: vm.state = DockerHostServerStatus.UNAVAILABLE vm.save() return self.__check_docker_host_server(vm).dic()
def get_and_check_host_server(self, host_server_id): """ first get the docker host DB object for a hackathon, and check whether the container_count is correct through "Docker Restful API", if not, update this value in the database. :param host_server_id: the id of host_server in DB :type host_server_id: Integer :return: A object of docker_host_server :rtype: DockerHostServer object or None """ host_server = DockerHostServer.objects(id=host_server_id).first() if host_server is None: self.log.warn('get docker_host fail, not find host server by id:' + host_server_id) return not_found("docker host server not found") ping = self.docker.ping(host_server) if not ping: host_server.state = DockerHostServerStatus.UNAVAILABLE host_server.save() else: try: containers = self.docker.list_containers(host_server) if len(containers) != host_server.container_count: host_server.container_count = len(containers) host_server.save() except Exception as e: self.log.error("Failed in sync container count") self.log.error(e) return self.__check_docker_host_server(host_server).dic()
def query_vm_status_for_release(self, context): vm_adapter = self.__get_azure_vm_adapter(context) try: context.trial = context.get("trial", 0) + 1 result = vm_adapter.get_virtual_machine_instance_status( context.cloud_service_name, DEPLOYMENT_SLOT, context.virtual_machine_name) if result is None: self.log.error("cannot find vm or deployment slot") self._on_virtual_environment_unexpected_error(context) elif result == AVMStatus.READY_ROLE: host_server = DockerHostServer.objects( id=context.host_server_id).first() self.__stop_docker_container(context, host_server) elif context.trial > MAX_TRIAL: self._on_virtual_environment_unexpected_error(context) else: self.log.debug( 'wait for virtual machine [%r] loop count [%d]' % (context.virtual_machine_name, context.trial)) self.scheduler.add_once(FEATURE, "query_vm_status", context, seconds=TRIAL_INTERVAL_SECONDS) except Exception as e: self.log.error(e) self.scheduler.add_once(FEATURE, "query_vm_status_for_release", context, seconds=TRIAL_INTERVAL_SECONDS)
def update_host_server(self, args): """ update a docker host_server's information for a hackathon. :param hackathon_id: the id of hackathon in DB :type hackathon_id: Integer :return: ok() if succeed. not_found(...) if fail to update the docker_host's information """ vm = DockerHostServer.objects(id=args.id).first() if vm is None: self.log.warn('delete docker_host fail, not find hostserver_id:' + args.id) return not_found("", "host_server not found") vm.vm_name = args.get("vm_name", vm.vm_name) vm.public_dns = args.get("public_dns", vm.public_dns) vm.public_ip = args.get("public_ip", vm.public_ip) vm.private_ip = args.get("private_ip", vm.private_ip) vm.container_max_count = int( args.get("container_max_count", vm.container_max_count)) vm.public_docker_api_port = int( args.get("public_docker_api_port", vm.public_docker_api_port)) vm.private_docker_api_port = int( args.get("private_docker_api_port", vm.private_docker_api_port)) vm.disabled = args.get("disabled", vm.disabled) if self.docker.ping(vm): vm.state = DockerHostServerStatus.DOCKER_READY else: vm.state = DockerHostServerStatus.UNAVAILABLE vm.save() return self.__check_docker_host_server(vm).dic()
def add_host_server(self, hackathon, args): """ create a docker host DB object for a hackathon and insert record into the database. param-"args" contain all necessary infos to new a docker_host :return: return True if succeed, otherwise return False :rtype: bool """ host_server = DockerHostServer( vm_name=args.vm_name, public_dns=args.public_dns, public_ip=args.public_ip, public_docker_api_port=args.public_docker_api_port, private_ip=args.private_ip, private_docker_api_port=args.private_docker_api_port, container_count=0, container_max_count=args.container_max_count, is_auto=False, disabled=args.get("disabled", False), hackathon=hackathon) if self.docker.ping(host_server): host_server.state = DockerHostServerStatus.DOCKER_READY else: host_server.state = DockerHostServerStatus.UNAVAILABLE host_server.save() return host_server.dic()
def __update_virtual_environment_cfg(self, context): experiment = Experiment.objects( id=context.experiment_id).no_dereference().first() virtual_environment = experiment.virtual_environments.get( name=context.virtual_environment_name) host_server = DockerHostServer.objects( id=context.host_server_id).first() # azure_key if not self.util.is_local(): experiment.azure_key = AzureKey.objects( id=context.azure_key_id).first() # update port binding for cfg in context.port_config: public_port = cfg[ DOCKER_UNIT. PORTS_PUBLIC_PORT] if DOCKER_UNIT.PORTS_PUBLIC_PORT in cfg else None port_binding = PortBinding( name=cfg[DOCKER_UNIT.PORTS_NAME], is_public=bool(cfg[DOCKER_UNIT.PORTS_PUBLIC]), public_port=public_port, host_port=cfg[DOCKER_UNIT.PORTS_HOST_PORT], container_port=cfg[DOCKER_UNIT.PORTS_PORT]) if DOCKER_UNIT.PORTS_URL in cfg: port_binding.url = cfg[DOCKER_UNIT.PORTS_URL] virtual_environment.docker_container.port_bindings.append( port_binding) # guacamole config guacamole = context.unit.get_remote() port_cfg = filter( lambda p: p[DOCKER_UNIT.PORTS_PORT] == guacamole[ DOCKER_UNIT.REMOTE_PORT], context.port_config) if len(port_cfg) > 0: virtual_environment.remote_provider = VERemoteProvider.Guacamole gc = { "displayname": context.virtual_environment_name, "name": context.virtual_environment_name, "protocol": guacamole[DOCKER_UNIT.REMOTE_PROTOCOL], "hostname": host_server.public_ip, "port": port_cfg[0][DOCKER_UNIT.PORTS_PUBLIC_PORT], "enable-sftp": True } if DOCKER_UNIT.REMOTE_USERNAME in guacamole: gc["username"] = guacamole[DOCKER_UNIT.REMOTE_USERNAME] if DOCKER_UNIT.REMOTE_PASSWORD in guacamole: gc["password"] = guacamole[DOCKER_UNIT.REMOTE_PASSWORD] # save guacamole config into DB virtual_environment.remote_paras = gc experiment.save() # start container self.__start_docker_container(context, experiment, host_server)
def get_host_server_by_id(self, id_): """ Search host server in DB by id :param id_: the id of host server in DB :type id_: integer :return: the found host server information in DB :rtype: DockerHostServer object """ return DockerHostServer.objects(id=id_).first()
def get_docker_hosts_list(self, hackathon): """ Get all host servers of a hackathon :param hackathon_id: the id of this hackathon, on_success callback function :type hackathon_id: integer :return: a list of all docker hosts :rtype: list """ host_servers = DockerHostServer.objects(hackathon=hackathon) return [host_server.dic() for host_server in host_servers]
def add_host_server(self, hackathon, args): """ create a docker host DB object for a hackathon and insert record into the database. param-"args" contain all necessary infos to new a docker_host :return: return True if succeed, otherwise return False :rtype: bool """ host_server = DockerHostServer(vm_name=args.vm_name, public_dns=args.public_dns, public_ip=args.public_ip, public_docker_api_port=args.public_docker_api_port, private_ip=args.private_ip, private_docker_api_port=args.private_docker_api_port, container_count=0, container_max_count=args.container_max_count, is_auto=False, disabled=args.get("disabled", False), hackathon=hackathon) if self.docker.ping(host_server): host_server.state = DockerHostServerStatus.DOCKER_READY else: host_server.state = DockerHostServerStatus.UNAVAILABLE host_server.save() return host_server.dic()
def __create_default_data_for_local(self, hackathon): """ create test data for new hackathon. It's for local development only :param hackathon: :return: """ try: # test docker host server host = DockerHostServer(vm_name="localhost", public_dns="localhost", public_ip="127.0.0.1", public_docker_api_port=4243, private_ip="127.0.0.1", private_docker_api_port=4243, container_count=0, container_max_count=100, disabled=False, state=DockerHostServerStatus.DOCKER_READY, hackathon=hackathon) host.save() except Exception as e: self.log.error(e) self.log.warn("fail to create test data")
def __update_virtual_environment_cfg(self, context): experiment = Experiment.objects(id=context.experiment_id).no_dereference().first() virtual_environment = experiment.virtual_environments.get(name=context.virtual_environment_name) host_server = DockerHostServer.objects(id=context.host_server_id).first() # azure_key if not self.util.is_local(): experiment.azure_key = AzureKey.objects(id=context.azure_key_id).first() # update port binding for cfg in context.port_config: public_port = cfg[DOCKER_UNIT.PORTS_PUBLIC_PORT] if DOCKER_UNIT.PORTS_PUBLIC_PORT in cfg else None port_binding = PortBinding(name=cfg[DOCKER_UNIT.PORTS_NAME], is_public=bool(cfg[DOCKER_UNIT.PORTS_PUBLIC]), public_port=public_port, host_port=cfg[DOCKER_UNIT.PORTS_HOST_PORT], container_port=cfg[DOCKER_UNIT.PORTS_PORT]) if DOCKER_UNIT.PORTS_URL in cfg: port_binding.url = cfg[DOCKER_UNIT.PORTS_URL] virtual_environment.docker_container.port_bindings.append(port_binding) # guacamole config guacamole = context.unit.get_remote() port_cfg = filter(lambda p: p[DOCKER_UNIT.PORTS_PORT] == guacamole[DOCKER_UNIT.REMOTE_PORT], context.port_config) if len(port_cfg) > 0: virtual_environment.remote_provider = VERemoteProvider.Guacamole gc = { "displayname": context.virtual_environment_name, "name": context.virtual_environment_name, "protocol": guacamole[DOCKER_UNIT.REMOTE_PROTOCOL], "hostname": host_server.public_ip, "port": port_cfg[0][DOCKER_UNIT.PORTS_PUBLIC_PORT], "enable-sftp": True } if DOCKER_UNIT.REMOTE_USERNAME in guacamole: gc["username"] = guacamole[DOCKER_UNIT.REMOTE_USERNAME] if DOCKER_UNIT.REMOTE_PASSWORD in guacamole: gc["password"] = guacamole[DOCKER_UNIT.REMOTE_PASSWORD] # save guacamole config into DB virtual_environment.remote_paras = gc experiment.save() # start container self.__start_docker_container(context, experiment, host_server)
def query_vm_status_for_release(self, context): vm_adapter = self.__get_azure_vm_adapter(context) try: context.trial = context.get("trial", 0) + 1 result = vm_adapter.get_virtual_machine_instance_status(context.cloud_service_name, DEPLOYMENT_SLOT, context.virtual_machine_name) if result is None: self.log.error("cannot find vm or deployment slot") self._on_virtual_environment_unexpected_error(context) elif result == AVMStatus.READY_ROLE: host_server = DockerHostServer.objects(id=context.host_server_id).first() self.__stop_docker_container(context, host_server) elif context.trial > MAX_TRIAL: self._on_virtual_environment_unexpected_error(context) else: self.log.debug( 'wait for virtual machine [%r] loop count [%d]' % (context.virtual_machine_name, context.trial)) self.scheduler.add_once(FEATURE, "query_vm_status", context, seconds=TRIAL_INTERVAL_SECONDS) except Exception as e: self.log.error(e) self.scheduler.add_once(FEATURE, "query_vm_status_for_release", context, seconds=TRIAL_INTERVAL_SECONDS)