def launch(self, inf, radl, requested_radl, num_vm, auth_data): server = ServerProxy(self.server_url, allow_none=True) session_id = self.getSessionID(auth_data) if session_id is None: return [( False, "Incorrect auth data, username and password must be specified for OpenNebula provider." )] sgs = self.create_security_groups(inf, radl, auth_data) system = radl.systems[0] # Currently ONE plugin prioritizes user-password credentials if system.getValue('disk.0.os.credentials.password'): system.delValue('disk.0.os.credentials.private_key') system.delValue('disk.0.os.credentials.public_key') res = [] i = 0 while i < num_vm: vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) vm.destroy = True inf.add_vm(vm) template = self.getONETemplate(vm.info, sgs, auth_data, vm) self.log_debug("ONE Template: %s" % template) success, res_id = server.one.vm.allocate(session_id, template)[0:2] if success: vm.id = str(res_id) vm.info.systems[0].setValue('instance_id', str(res_id)) vm.destroy = False res.append((success, vm)) else: res.append((success, "ERROR: " + str(res_id))) i += 1 return res
def launch(self, inf, radl, requested_radl, num_vm, auth_data): driver = self.get_driver(auth_data) system = radl.systems[0] image_id = self.get_image_id(system.getValue("disk.0.image.url")) image = NodeImage(id=image_id, name=None, driver=driver) instance_type = self.get_instance_type(driver.list_sizes(), system) name = system.getValue("instance_name") if not name: name = system.getValue("disk.0.image.name") if not name: name = "userimage" sgs = self.create_security_groups(driver, inf, radl) args = { 'size': instance_type, 'image': image, 'ex_security_groups': sgs, 'name': "%s-%s" % (name, str(uuid.uuid1())) } if system.getValue('availability_zone'): args['location'] = system.getValue('availability_zone') keypair = None public_key = system.getValue("disk.0.os.credentials.public_key") if public_key and public_key.find('-----BEGIN CERTIFICATE-----') == -1: public_key = None keypair = driver.get_key_pair(public_key) if keypair: system.setUserKeyCredentials(system.getCredentials().username, None, keypair.private_key) else: args["ex_keyname"] = keypair.name else: public_key, private_key = self.keygen() system.setUserKeyCredentials(system.getCredentials().username, None, private_key) user = system.getValue('disk.0.os.credentials.username') if not user: user = self.DEFAULT_USER system.setValue('disk.0.os.credentials.username', user) tags = self.get_instance_tags(system) res = [] i = 0 while i < num_vm: self.log_debug("Creating node") vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self.cloud.getCloudConnector(inf)) vm.destroy = True inf.add_vm(vm) cloud_init = self.get_cloud_init_data(radl, vm, public_key, user) if cloud_init: args['ex_userdata'] = cloud_init msg = "Error creating the node" try: node = driver.create_node(**args) except Exception as ex: msg += ": %s" % str(ex) self.log_exception("Error creating node.") node = None if node: if tags: try: driver.ex_create_tags([node.id], tags) except: self.log_exception("Error adding tags to node %s." % node.id) vm.id = node.id vm.info.systems[0].setValue('instance_id', str(node.id)) vm.info.systems[0].setValue('instance_name', str(node.name)) if 'zone_name' in node.extra: vm.info.systems[0].setValue('availability_zone', node.extra["zone_name"]) self.log_debug("Node successfully created.") vm.destroy = False inf.add_vm(vm) res.append((True, vm)) else: res.append((False, msg)) i += 1 return res
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] public_net = None for net in radl.networks: if net.isPublic(): public_net = net outports = None if public_net: outports = public_net.getOutPorts() apiVersion = self.get_api_version(auth_data) res = [] namespace = inf.id headers = {'Content-Type': 'application/json'} uri = "/api/" + apiVersion + "/namespaces" with inf._lock: resp = self.create_request('GET', uri + "/" + namespace, auth_data, headers) if resp.status_code != 200: namespace_data = { 'apiVersion': apiVersion, 'kind': 'Namespace', 'metadata': { 'name': namespace } } body = json.dumps(namespace_data) resp = self.create_request('POST', uri, auth_data, headers, body) if resp.status_code != 201: for _ in range(num_vm): res.append( (False, "Error creating the Namespace: " + resp.text)) return res i = 0 while i < num_vm: try: i += 1 vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) (nodename, _) = vm.getRequestedName( default_hostname=Config.DEFAULT_VM_NAME, default_domain=Config.DEFAULT_DOMAIN) pod_name = nodename # Do not use the Persistent volumes yet volumes = self._create_volumes(apiVersion, namespace, system, pod_name, auth_data) ssh_port = (KubernetesCloudConnector._port_base_num + KubernetesCloudConnector._port_counter) % 65535 KubernetesCloudConnector._port_counter += 1 pod_data = self._generate_pod_data(apiVersion, namespace, pod_name, outports, system, ssh_port, volumes) body = json.dumps(pod_data) uri = "/api/" + apiVersion + "/namespaces/" + namespace + "/pods" resp = self.create_request('POST', uri, auth_data, headers, body) if resp.status_code != 201: res.append( (False, "Error creating the Container: " + resp.text)) else: output = json.loads(resp.text) vm.id = output["metadata"]["name"] # Set SSH port in the RADL info of the VM vm.setSSHPort(ssh_port) # Set the default user and password to access the container vm.info.systems[0].setValue( 'disk.0.os.credentials.username', 'root') vm.info.systems[0].setValue( 'disk.0.os.credentials.password', self._root_password) vm.info.systems[0].setValue('instance_id', str(vm.id)) vm.info.systems[0].setValue('instance_name', str(vm.id)) res.append((True, vm)) except Exception as ex: self.log_exception( "Error connecting with Kubernetes API server") res.append((False, "ERROR: " + str(ex))) return res
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] public_net = None for net in radl.networks: if net.isPublic(): public_net = net outports = None if public_net: outports = public_net.getOutPorts() conn = self.get_http_connection(auth_data) res = [] i = 0 while i < num_vm: try: i += 1 ssh_port = 22 if public_net: ssh_port = (DockerCloudConnector._port_base_num + DockerCloudConnector._port_counter) % 65535 DockerCloudConnector._port_counter += 1 # Create the VM to get the nodename vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) # Create the container conn.putrequest('POST', "/containers/create") conn.putheader('Content-Type', 'application/json') cont_data = self._generate_create_request_data( outports, system, vm, ssh_port) body = json.dumps(cont_data) conn.putheader('Content-Length', len(body)) conn.endheaders(body) resp = conn.getresponse() output = resp.read() if resp.status != 201: res.append( (False, "Error creating the Container: " + output)) continue output = json.loads(output) # Set the cloud id to the VM vm.id = output["Id"] vm.info.systems[0].setValue('instance_id', str(vm.id)) # Now start it success, _ = self.start(vm, auth_data) if not success: res.append( (False, "Error starting the Container: " + str(output))) # Delete the container conn.request('DELETE', "/containers/" + vm.id) resp = conn.getresponse() resp.read() continue # Set the default user and password to access the container vm.info.systems[0].setValue( 'disk.0.os.credentials.username', 'root') vm.info.systems[0].setValue( 'disk.0.os.credentials.password', self._root_password) # Set ssh port in the RADL info of the VM vm.setSSHPort(ssh_port) res.append((True, vm)) except Exception, ex: self.logger.exception("Error connecting with Docker server") res.append((False, "ERROR: " + str(ex)))
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] public_net = None for net in radl.networks: if net.isPublic(): public_net = net outports = None if public_net: outports = public_net.getOutPorts() auth_header = self.get_auth_header(auth_data) conn = self.get_http_connection() apiVersion = self.get_api_version(auth_data) res = [] i = 0 while i < num_vm: try: i += 1 namespace = "im%d" % int(time.time() * 100) vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) (nodename, _) = vm.getRequestedName( default_hostname=Config.DEFAULT_VM_NAME, default_domain=Config.DEFAULT_DOMAIN) pod_name = nodename # Do not use the Persistent volumes yet volumes = self._create_volumes( apiVersion, namespace, system, pod_name, auth_data) # Create the pod conn.putrequest('POST', "/api/" + apiVersion + "/namespaces/" + namespace + "/pods") conn.putheader('Content-Type', 'application/json') if auth_header: conn.putheader(auth_header.keys()[ 0], auth_header.values()[0]) ssh_port = (KubernetesCloudConnector._port_base_num + KubernetesCloudConnector._port_counter) % 65535 KubernetesCloudConnector._port_counter += 1 pod_data = self._generate_pod_data( apiVersion, namespace, pod_name, outports, system, ssh_port, volumes) body = json.dumps(pod_data) conn.putheader('Content-Length', len(body)) conn.endheaders(body) resp = conn.getresponse() output = resp.read() if resp.status != 201: res.append( (False, "Error creating the Container: " + output)) else: output = json.loads(output) vm.id = output["metadata"]["namespace"] + \ "/" + output["metadata"]["name"] # Set SSH port in the RADL info of the VM vm.setSSHPort(ssh_port) # Set the default user and password to access the container vm.info.systems[0].setValue( 'disk.0.os.credentials.username', 'root') vm.info.systems[0].setValue( 'disk.0.os.credentials.password', self._root_password) vm.info.systems[0].setValue('instance_id', str(vm.id)) vm.info.systems[0].setValue('instance_name', str(vm.id)) res.append((True, vm)) except Exception, ex: self.logger.exception( "Error connecting with Kubernetes API server") res.append((False, "ERROR: " + str(ex)))
def launch(self, inf, radl, requested_radl, num_vm, auth_data): location = self.DEFAULT_LOCATION if radl.systems[0].getValue('availability_zone'): location = radl.systems[0].getValue('availability_zone') else: radl.systems[0].setValue('availability_zone', location) credentials, subscription_id = self.get_credentials(auth_data) resource_client = ResourceManagementClient(credentials, subscription_id) with inf._lock: # Create resource group for the Infrastructure inf_rg = None try: inf_rg = resource_client.resource_groups.get("rg-%s" % inf.id) except Exception: pass if not inf_rg: resource_client.resource_groups.create_or_update( "rg-%s" % inf.id, {'location': location}) subnets = self.create_nets(inf, radl, credentials, subscription_id, "rg-%s" % inf.id) res = [] i = 0 while i < num_vm: try: # Create the VM to get the nodename now = int(time.time() * 100) vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) group_name = "rg-%s-%d" % (inf.id, vm.im_id) storage_account_name = "st%d%d" % (now, vm.im_id) vm_name = radl.systems[0].getValue("instance_name") if vm_name: vm_name = "%s%d" % (vm_name, now) else: vm_name = "userimage%d" % now # Create resource group for the VM resource_client.resource_groups.create_or_update( group_name, {'location': location}) # Create storage account storage_account, error_msg = self.create_storage_account( group_name, storage_account_name, credentials, subscription_id, location) if not storage_account: res.append((False, error_msg)) resource_client.resource_groups.delete(group_name) break nics = self.create_nics(inf, radl, credentials, subscription_id, group_name, subnets) instance_type = self.get_instance_type(radl.systems[0], credentials, subscription_id) vm_parameters = self.get_azure_vm_create_json( storage_account_name, vm_name, nics, radl, instance_type) compute_client = ComputeManagementClient( credentials, subscription_id) async_vm_creation = compute_client.virtual_machines.create_or_update( group_name, vm_name, vm_parameters) azure_vm = async_vm_creation.result() # Set the cloud id to the VM vm.id = group_name + '/' + vm_name vm.info.systems[0].setValue('instance_id', group_name + '/' + vm_name) self.attach_data_disks(vm, storage_account_name, credentials, subscription_id, location) res.append((True, vm)) except Exception as ex: self.log_exception("Error creating the VM") res.append((False, "Error creating the VM: " + str(ex))) # Delete Resource group and everything in it resource_client.resource_groups.delete(group_name) i += 1 return res
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] auth_header = self.get_auth_header(auth_data) cpu = system.getValue('cpu.count') memory = None if system.getFeature('memory.size'): memory = system.getFeature('memory.size').getValue('G') name = system.getValue("instance_name") if not name: name = system.getValue("disk.0.image.name") if not name: name = "im_userimage" arch = system.getValue('cpu.arch') if arch.find('64'): arch = 'x64' else: arch = 'x86' res = [] i = 0 public_key = system.getValue('disk.0.os.credentials.public_key') password = system.getValue('disk.0.os.credentials.password') if public_key: if password: system.delValue('disk.0.os.credentials.password') password = None else: if not password: # We must generate them (public_key, private_key) = self.keygen() system.setValue('disk.0.os.credentials.private_key', private_key) user = system.getValue('disk.0.os.credentials.username') if not user: user = self.DEFAULT_USER system.setValue('disk.0.os.credentials.username', user) user_data = "" if public_key: # Add user cloud init data cloud_config_str = self.get_cloud_init_data(radl) cloud_config = self.gen_cloud_config(public_key, user, cloud_config_str) user_data = base64.b64encode(cloud_config).replace("\n", "") self.logger.debug("Cloud init: " + cloud_config) # Get the info about the OCCI server (GET /-/) occi_info = self.query_occi(auth_data) # Parse the info to get the os_tpl scheme url = uriparse(system.getValue("disk.0.image.url")) # Get the Image ID from the last part of the path os_tpl = os.path.basename(url[2]) os_tpl_scheme = self.get_os_tpl_scheme(occi_info, os_tpl) if not os_tpl_scheme: raise Exception( "Error getting os_tpl scheme. Check that the image specified is supported in the OCCI server.") # Parse the info to get the instance_type (resource_tpl) scheme instance_type_uri = None if system.getValue('instance_type'): instance_type = self.get_instance_type_uri( occi_info, system.getValue('instance_type')) instance_type_uri = uriparse(instance_type) if not instance_type_uri[5]: raise Exception("Error getting Instance type URI. Check that the instance_type specified is " "supported in the OCCI server.") else: instance_name = instance_type_uri[5] instance_scheme = instance_type_uri[ 0] + "://" + instance_type_uri[1] + instance_type_uri[2] + "#" while i < num_vm: volumes = [] try: # First create the volumes volumes = self.create_volumes(system, auth_data) body = 'Category: compute; scheme="http://schemas.ogf.org/occi/infrastructure#"; class="kind"\n' body += 'Category: ' + os_tpl + '; scheme="' + \ os_tpl_scheme + '"; class="mixin"\n' body += 'Category: user_data; scheme="http://schemas.openstack.org/compute/instance#"; class="mixin"\n' # body += 'Category: public_key; # scheme="http://schemas.openstack.org/instance/credentials#"; # class="mixin"\n' if instance_type_uri: body += 'Category: ' + instance_name + '; scheme="' + \ instance_scheme + '"; class="mixin"\n' else: # Try to use this OCCI attributes (not supported by # openstack) if cpu: body += 'X-OCCI-Attribute: occi.compute.cores=' + \ str(cpu) + '\n' # body += 'X-OCCI-Attribute: occi.compute.architecture=' + arch +'\n' if memory: body += 'X-OCCI-Attribute: occi.compute.memory=' + \ str(memory) + '\n' compute_id = "im." + str(int(time.time() * 100)) body += 'X-OCCI-Attribute: occi.core.id="' + compute_id + '"\n' body += 'X-OCCI-Attribute: occi.core.title="' + name + '"\n' # Set the hostname defined in the RADL # Create the VM to get the nodename vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) (nodename, _) = vm.getRequestedName(default_hostname=Config.DEFAULT_VM_NAME, default_domain=Config.DEFAULT_DOMAIN) body += 'X-OCCI-Attribute: occi.compute.hostname="' + nodename + '"\n' # See: https://wiki.egi.eu/wiki/HOWTO10 # body += 'X-OCCI-Attribute: org.openstack.credentials.publickey.name="my_key"' # body += 'X-OCCI-Attribute: org.openstack.credentials.publickey.data="ssh-rsa BAA...zxe ==user@host"' if user_data: body += 'X-OCCI-Attribute: org.openstack.compute.user_data="' + user_data + '"\n' # Add volume links for device, volume_id in volumes: body += ('Link: <%s/storage/%s>;rel="http://schemas.ogf.org/occi/infrastructure#storage";' 'category="http://schemas.ogf.org/occi/infrastructure#storagelink";' 'occi.core.target="%s/storage/%s";occi.core.source="%s/compute/%s"' '' % (self.cloud.path, volume_id, self.cloud.path, volume_id, self.cloud.path, compute_id)) if device: body += ';occi.storagelink.deviceid="/dev/%s"\n' % device body += '\n' self.logger.debug(body) headers = {'Accept': 'text/plain', 'Connection': 'close', 'Content-Type': 'text/plain,text/occi'} if auth_header: headers.update(auth_header) resp = self.create_request('POST', self.cloud.path + "/compute/", auth_data, headers, body) # some servers return 201 and other 200 if resp.status_code != 201 and resp.status_code != 200: res.append((False, resp.reason + "\n" + resp.text)) for _, volume_id in volumes: self.delete_volume(volume_id, auth_data) else: occi_vm_id = os.path.basename(resp.text) if occi_vm_id: vm.id = occi_vm_id vm.info.systems[0].setValue('instance_id', str(occi_vm_id)) res.append((True, vm)) else: res.append((False, 'Unknown Error launching the VM.')) except Exception, ex: self.logger.exception("Error connecting with OCCI server") res.append((False, "ERROR: " + str(ex))) for _, volume_id in volumes: self.delete_volume(volume_id, auth_data) i += 1
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] public_net = None for net in radl.networks: if net.isPublic(): public_net = net outports = None if public_net: outports = public_net.getOutPorts() conn = self.get_http_connection(auth_data) res = [] i = 0 while i < num_vm: try: i += 1 ssh_port = 22 if public_net: ssh_port = (DockerCloudConnector._port_base_num + DockerCloudConnector._port_counter) % 65535 DockerCloudConnector._port_counter += 1 # Create the VM to get the nodename vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) # Create the container conn.putrequest('POST', "/containers/create") conn.putheader('Content-Type', 'application/json') cont_data = self._generate_create_request_data( outports, system, vm, ssh_port) body = json.dumps(cont_data) conn.putheader('Content-Length', len(body)) conn.endheaders(body) resp = conn.getresponse() output = resp.read() if resp.status != 201: res.append( (False, "Error creating the Container: " + output)) continue output = json.loads(output) # Set the cloud id to the VM vm.id = output["Id"] vm.info.systems[0].setValue('instance_id', str(vm.id)) # Now start it success, _ = self.start(vm, auth_data) if not success: res.append( (False, "Error starting the Container: " + str(output))) # Delete the container conn.request('DELETE', "/containers/" + vm.id) resp = conn.getresponse() resp.read() continue # Set the default user and password to access the container vm.info.systems[0].setValue('disk.0.os.credentials.username', 'root') vm.info.systems[0].setValue('disk.0.os.credentials.password', self._root_password) # Set ssh port in the RADL info of the VM vm.setSSHPort(ssh_port) res.append((True, vm)) except Exception, ex: self.logger.exception("Error connecting with Docker server") res.append((False, "ERROR: " + str(ex)))
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] # Get the public network connected with this VM public_net = None for net in radl.networks: if net.isPublic() and system.getNumNetworkWithConnection( net.id) is not None: public_net = net outports = None if public_net: outports = public_net.getOutPorts() self._create_networks(inf, radl, auth_data) with inf._lock: self._create_volumes(system, auth_data) headers = {'Content-Type': 'application/json'} res = [] i = 0 while i < num_vm: try: i += 1 # Create the VM to get the nodename vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) ssh_port = 22 if vm.hasPublicNet(): ssh_port = (DockerCloudConnector._port_base_num + DockerCloudConnector._port_counter) % 65535 DockerCloudConnector._port_counter += 1 # The URI has this format: docker://image_name full_image_name = system.getValue("disk.0.image.url")[9:] # Create the container if self._is_swarm(auth_data): cont_data = self._generate_create_svc_request_data( full_image_name, outports, vm, ssh_port, auth_data) resp = self.create_request('POST', "/services/create", auth_data, headers, cont_data) else: # First we have to pull the image image_parts = full_image_name.split(":") image_name = image_parts[0] if len(image_parts) < 2: tag = "latest" else: tag = image_parts[1] resp = self.create_request( 'POST', "/images/create?fromImage=%s&tag=%s" % (image_name, tag), auth_data, headers) if resp.status_code not in [201, 200]: res.append( (False, "Error pulling the image: " + resp.text)) continue cont_data = self._generate_create_cont_request_data( full_image_name, outports, vm, ssh_port, auth_data) resp = self.create_request('POST', "/containers/create", auth_data, headers, cont_data) if resp.status_code != 201: res.append( (False, "Error creating the Container: " + resp.text)) continue output = json.loads(resp.text) # Set the cloud id to the VM if "Id" in output: vm.id = output["Id"] elif "ID" in output: vm.id = output["ID"] else: res.append((False, "Error: response format not expected.")) vm.info.systems[0].setValue('instance_id', str(vm.id)) if not self._is_swarm(auth_data): # In creation a container can only be attached to one one network # so now we must attach to the rest of networks (if any) success = self._attach_cont_to_networks(vm, auth_data) if not success: res.append( (False, "Error attaching to networks the Container")) # Delete the container resp = self.create_request('DELETE', "/containers/" + vm.id, auth_data) continue # Now start it success, msg = self.start(vm, auth_data) if not success: res.append( (False, "Error starting the Container: " + str(msg))) # Delete the container resp = self.create_request('DELETE', "/containers/" + vm.id, auth_data) continue # Set the default user and password to access the container vm.info.systems[0].setValue('disk.0.os.credentials.username', 'root') vm.info.systems[0].setValue('disk.0.os.credentials.password', self._root_password) # Set ssh port in the RADL info of the VM vm.setSSHPort(ssh_port) res.append((True, vm)) except Exception, ex: self.logger.exception("Error connecting with Docker server") res.append((False, "ERROR: " + str(ex)))
def launch(self, inf, radl, requested_radl, num_vm, auth_data): system = radl.systems[0] public_net = None for net in radl.networks: if net.isPublic(): public_net = net outports = None if public_net: outports = public_net.getOutPorts() auth_header = self.get_auth_header(auth_data) conn = self.get_http_connection() apiVersion = self.get_api_version(auth_data) res = [] i = 0 while i < num_vm: try: i += 1 namespace = "im%d" % int(time.time() * 100) vm = VirtualMachine(inf, None, self.cloud, radl, requested_radl, self) (nodename, _) = vm.getRequestedName( default_hostname=Config.DEFAULT_VM_NAME, default_domain=Config.DEFAULT_DOMAIN) pod_name = nodename # Do not use the Persistent volumes yet volumes = self._create_volumes(apiVersion, namespace, system, pod_name, auth_data) # Create the pod conn.putrequest( 'POST', "/api/" + apiVersion + "/namespaces/" + namespace + "/pods") conn.putheader('Content-Type', 'application/json') if auth_header: conn.putheader(auth_header.keys()[0], auth_header.values()[0]) ssh_port = (KubernetesCloudConnector._port_base_num + KubernetesCloudConnector._port_counter) % 65535 KubernetesCloudConnector._port_counter += 1 pod_data = self._generate_pod_data(apiVersion, namespace, pod_name, outports, system, ssh_port, volumes) body = json.dumps(pod_data) conn.putheader('Content-Length', len(body)) conn.endheaders(body) resp = conn.getresponse() output = resp.read() if resp.status != 201: res.append( (False, "Error creating the Container: " + output)) else: output = json.loads(output) vm.id = output["metadata"]["namespace"] + \ "/" + output["metadata"]["name"] # Set SSH port in the RADL info of the VM vm.setSSHPort(ssh_port) # Set the default user and password to access the container vm.info.systems[0].setValue( 'disk.0.os.credentials.username', 'root') vm.info.systems[0].setValue( 'disk.0.os.credentials.password', self._root_password) vm.info.systems[0].setValue('instance_id', str(vm.id)) vm.info.systems[0].setValue('instance_name', str(vm.id)) res.append((True, vm)) except Exception, ex: self.logger.exception( "Error connecting with Kubernetes API server") res.append((False, "ERROR: " + str(ex)))