Ejemplo n.º 1
0
def wait_for_task(vca_client, task):
    """
        check status of current task and make request for recheck
        task status in case when we have not well defined state
        (not error and not success or by timeout)
    """
    WAIT_TIME_MAX_MINUTES = 30
    TASK_RECHECK_TIMEOUT = 5
    TASK_STATUS_SUCCESS = 'success'
    TASK_STATUS_ERROR = 'error'
    MAX_ATTEMPTS = WAIT_TIME_MAX_MINUTES * 60 / TASK_RECHECK_TIMEOUT
    print('Maximun task wait time {0} minutes.'.format(WAIT_TIME_MAX_MINUTES))
    print('Task recheck after {0} seconds.'.format(TASK_RECHECK_TIMEOUT))
    status = task.get_status()
    for attempt in range(MAX_ATTEMPTS):
        print('Attempt: {0}/{1}.'.format(attempt + 1, MAX_ATTEMPTS))
        if status == TASK_STATUS_SUCCESS:
            print('Task completed in {0} seconds'.format(attempt *
                                                         TASK_RECHECK_TIMEOUT))
            return
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise cfy_exc.NonRecoverableError(
                "Error during task execution: {0}".format(error.get_message()))
        time.sleep(TASK_RECHECK_TIMEOUT)
        response = requests.get(
            task.get_href(),
            headers=vca_client.vcloud_session.get_vcloud_headers())
        task = taskType.parseString(response.content, True)
        status = task.get_status()
    raise cfy_exc.NonRecoverableError("Wait for task timeout.")
Ejemplo n.º 2
0
 def block_until_completed(self, task):
     progress = task.get_Progress()
     status = task.get_status()
     rnd = 0
     while status != "success":
         if status == "error":
             error = task.get_Error()
             Log.error(self.logger, "task error, major=%s, minor=%s, message=%s" % (error.get_majorErrorCode(), error.get_minorErrorCode(), error.get_message()))
             return False
         else:
             # some task doesn't not report progress
             if progress:
                 pass
             else:
                 rnd += 1
             time.sleep(1)
             self.response = Http.get(task.get_href(), headers=self.vcloud_session.get_vcloud_headers(), verify=self.verify, logger=self.logger)
             if self.response.status_code == requests.codes.ok:
                 task = taskType.parseString(self.response.content, True)
                 progress = task.get_Progress()
                 status = task.get_status()
             else:
                 Log.error(self.logger, "can't get task")
                 return False
     return True
Ejemplo n.º 3
0
 def delete_disk(self, vdc_name, name, id=None):
     vdc = self.get_vdc(vdc_name)
     refs = self.get_diskRefs(vdc)
     link = []
     if id is not None:
         link = filter(lambda link: link.get_href().endswith('/' + id),
                       refs)
     elif name is not None:
         link = filter(lambda link: link.get_name() == name, refs)
     if len(link) == 1:
         self.response = requests.delete(
             link[0].get_href(),
             headers=self.vcloud_session.get_vcloud_headers(),
             verify=self.verify)
         if self.response.status_code == requests.codes.accepted:
             task = taskType.parseString(self.response.content, True)
             return (True, task)
         else:
             return (False, self.response.content)
     elif len(link) == 0:
         return (False, 'disk not found')
     elif len(link) > 1:
         return (
             False,
             'more than one disks found with that name, use the disk id')
Ejemplo n.º 4
0
 def update_vms_connections(self, network_connections):
     children = self.me.get_Children()
     if children:
         vms = children.get_Vm()
         for vm in vms:
             network_connection = self._create_network_connection(network_connections)
             output = StringIO()
             network_connection.export(output,
                 0,
                 name_ = 'NetworkConnectionSection',
                 namespacedef_ = 'xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:vmw="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"',
                 pretty_print = True)
             body=output.getvalue().replace("vmw:Info", "ovf:Info")\
                                   .replace("<PrimaryNetworkConnectionIndex>", "<ovf:Info>Change network.</ovf:Info><PrimaryNetworkConnectionIndex>")
             response = self._invoke_api(requests, 'put',
                                         vm.get_href() + "/networkConnectionSection/",
                                         headers=self.headers,
                                         data=body,
                                         verify=self.verify)
             if response.status_code == requests.codes.forbidden:
                 raise exceptions.ForbiddenException("Update_vms_connections error")
             if response.status_code == requests.codes.accepted:
                 task = taskType.parseString(response.content, True)
                 return (True, task)
             else:
                 return (False, response.content)
Ejemplo n.º 5
0
def wait_for_task(vca_client, task):
    """
        check status of current task and make request for recheck
        task status in case when we have not well defined state
        (not error and not success or by timeout)
    """
    WAIT_TIME_MAX_MINUTES = 30
    MAX_ATTEMPTS = WAIT_TIME_MAX_MINUTES * 60 / TASK_RECHECK_TIMEOUT
    ctx.logger.debug('Maximun task wait time {0} minutes.'
                     .format(WAIT_TIME_MAX_MINUTES))
    ctx.logger.debug('Task recheck after {0} seconds.'
                     .format(TASK_RECHECK_TIMEOUT))
    status = task.get_status()
    config = get_vcloud_config()
    for attempt in xrange(MAX_ATTEMPTS):
        ctx.logger.debug('Attempt: {0}/{1}.'.format(attempt + 1, MAX_ATTEMPTS))
        if status == TASK_STATUS_SUCCESS:
            ctx.logger.debug('Task completed in {0} seconds'
                             .format(attempt * TASK_RECHECK_TIMEOUT))
            return
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise cfy_exc.NonRecoverableError(
                "Error during task execution: {0}".format(error.get_message()))
        time.sleep(TASK_RECHECK_TIMEOUT)
        response = requests.get(
            task.get_href(),
            headers=vca_client.vcloud_session.get_vcloud_headers(),
            verify=config.get('ssl_verify', True))
        task = taskType.parseString(response.content, True)
        status = task.get_status()
    raise cfy_exc.NonRecoverableError("Wait for task timeout.")
Ejemplo n.º 6
0
 def block_until_completed(self, task):
     progress = task.get_Progress()
     status = task.get_status()
     rnd = 0
     while status != "success":
         if status == "error":
             error = task.get_Error()
             return False
         else:
             # some task doesn't not report progress
             if progress:
                 pass
             else:
                 rnd += 1
             time.sleep(1)
             self.response = requests.get(
                 task.get_href(),
                 headers=self.vcloud_session.get_vcloud_headers(),
                 verify=self.verify)
             if self.response.status_code == requests.codes.ok:
                 task = taskType.parseString(self.response.content, True)
                 progress = task.get_Progress()
                 status = task.get_status()
             else:
                 return False
     return True
Ejemplo n.º 7
0
 def enableDownload(self):
     headers = self.headers
     url = '%s/action/enableDownload' % self.me.get_href()
     self.response = requests.post(url,data = {}, headers=headers, verify=self.verify)
     if self.response.status_code == requests.codes.accepted:
          return taskType.parseString(self.response.content, True)
     else:
         return False
Ejemplo n.º 8
0
 def _put(self, href, body):
     response = Http.put(
         href,
         data=body,
         headers=self._session.vca.vcloud_session.get_vcloud_headers(),
         verify=CONF.vcloud.verify)
     if response.status_code == requests.codes.accepted:
         return taskType.parseString(response.content, True)
     return None
Ejemplo n.º 9
0
 def delete_vdc_network(self, vdc_name, network_name):
     netref = self.get_admin_network_href(vdc_name, network_name)
     if netref is None:
         return (False, 'network not found')
     self.response = requests.delete(netref, headers=self.vcloud_session.get_vcloud_headers(), verify=self.verify)
     if self.response.status_code == requests.codes.accepted:
         task = taskType.parseString(self.response.content, True)
         return (True, task)
     else:
         return (False, self.response.content)
Ejemplo n.º 10
0
 def delete_vdc_network(self, vdc_name, network_name):
     netref = self.get_admin_network_href(vdc_name, network_name)
     if netref is None:
         return (False, 'network not found')
     self.response = requests.delete(netref, headers=self.vcloud_session.get_vcloud_headers(), verify=self.verify)
     if self.response.status_code == requests.codes.accepted:
         task = taskType.parseString(self.response.content, True)
         return (True, task)
     else:
         return (False, self.response.content)
Ejemplo n.º 11
0
 def enableDownload(self):
     headers = self.headers
     url = '%s/action/enableDownload' % self.me.get_href()
     self.response = requests.post(url,
                                   data={},
                                   headers=headers,
                                   verify=self.verify)
     if self.response.status_code == requests.codes.accepted:
         return taskType.parseString(self.response.content, True)
     else:
         return False
Ejemplo n.º 12
0
def save_gateway_configuration(gateway, vca_client):
    task = gateway.save_services_configuration()
    if task:
        wait_for_task(vca_client, task)
        return True
    else:
        error = taskType.parseString(gateway.response.content, True)
        if BUSY_MESSAGE in error.message:
            return False
        else:
            raise cfy_exc.NonRecoverableError(error.message)
 def enableDownload(self):
     headers = self.headers
     url = "%s/action/enableDownload" % self.me.get_href()
     self.response = requests.post(url, data={}, headers=headers, verify=self.verify)
     if self.response.status_code == requests.codes.accepted:
         return taskType.parseString(self.response.content, True)
     elif self.response.status_code == requests.codes.forbidden:
         LOG.error("enableDownloadfailed: forbidden vapp %s" % self.name)
         raise exceptions.ForbiddenException("enableDownloadfailed: forbidden vapp %s" % self.name)
     else:
         return False
Ejemplo n.º 14
0
 def _post(self, href, body, content_type):
     headers = self._session.vca.vcloud_session.get_vcloud_headers()
     headers['Content-type'] = content_type
     response = Http.post(
         href,
         data=body,
         headers=headers,
         verify=CONF.vcloud.verify)
     print response.content
     if response.status_code == requests.codes.accepted:
         return taskType.parseString(response.content, True)
     return None
Ejemplo n.º 15
0
 def get_task(self, task_id):
     if self.vcloud_session:
         o = urlparse(self.vcloud_session.url)
         link = '%s://%s%s/%s' % (o.scheme, o.netloc, '/api/task', task_id)
         self.response = Http.get(
             link,
             headers=self.vcloud_session.get_vcloud_headers(),
             verify=self.verify,
             logger=self.logger)
         if self.response.status_code == requests.codes.ok:
             return taskType.parseString(self.response.content, True)
         else:
             raise Exception(self.response.status_code)
     return None
Ejemplo n.º 16
0
def wait_for_task(vca_client, task):
    status = task.get_status()
    while status != TASK_STATUS_SUCCESS:
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise cfy_exc.NonRecoverableError(
                "Error during task execution: {0}".format(error.get_message()))
        else:
            time.sleep(TASK_RECHECK_TIMEOUT)
            response = requests.get(
                task.get_href(),
                headers=vca_client.vcloud_session.get_vcloud_headers())
            task = taskType.parseString(response.content, True)
            status = task.get_status()
Ejemplo n.º 17
0
 def enableDownload(self):
     headers = self.headers
     url = '%s/action/enableDownload' % self.me.get_href()
     self.response = requests.post(url,
                                   data={},
                                   headers=headers,
                                   verify=self.verify)
     if self.response.status_code == requests.codes.accepted:
         return taskType.parseString(self.response.content, True)
     elif self.response.status_code == requests.codes.forbidden:
         LOG.error("enableDownloadfailed: forbidden vapp %s" % self.name)
         raise exceptions.ForbiddenException(
             "enableDownloadfailed: forbidden vapp %s" % self.name)
     else:
         return False
Ejemplo n.º 18
0
def save_gateway_configuration(gateway, vca_client):
    """
        save gateway configuration,
        return everything successfully finished
        raise NonRecoverableError - can't get task description
    """
    task = gateway.save_services_configuration()
    if task:
        wait_for_task(vca_client, task)
        return True
    else:
        error = taskType.parseString(gateway.response.content, True)
        if BUSY_MESSAGE in error.message:
            return False
        else:
            raise cfy_exc.NonRecoverableError(error.message)
Ejemplo n.º 19
0
def save_gateway_configuration(gateway, vca_client):
    """
        save gateway configuration,
        return everything successfully finished
        raise NonRecoverableError - can't get task description
    """
    task = gateway.save_services_configuration()
    if task:
        wait_for_task(vca_client, task)
        return True
    else:
        error = taskType.parseString(gateway.response.content, True)
        if BUSY_MESSAGE in error.message:
            return False
        else:
            raise cfy_exc.NonRecoverableError(error.message)
Ejemplo n.º 20
0
    def delete_isolated_vdc_network(self, vdc_name, network_name):
        netref = self.get_isolated_network_href(vdc_name, network_name)
        if netref is None:
            return (True, None)
        response = requests.delete(
            netref,
            headers=self.vcloud_session.get_vcloud_headers(),
            verify=self.verify)

        if response.status_code == requests.codes.forbidden:
            raise exception.Forbidden("Delete_isolated_vdc_network error, " +
                                      "network_name:" + network_name)
        if response.status_code == requests.codes.accepted:
            task = taskType.parseString(response.content, True)
            return (True, task)
        else:
            return (False, response.content)
Ejemplo n.º 21
0
    def delete_isolated_vdc_network(self, vdc_name, network_name):
        netref = self.get_isolated_network_href(vdc_name, network_name)
        if netref is None:
            return (True, None)
        response = requests.delete(
            netref,
            headers=self.vcloud_session.get_vcloud_headers(),
            verify=self.verify)

        if response.status_code == requests.codes.forbidden:
            raise exception.Forbidden("Delete_isolated_vdc_network error, " +
                                      "network_name:" + network_name)
        if response.status_code == requests.codes.accepted:
            task = taskType.parseString(response.content, True)
            return (True, task)
        else:
            return (False, response.content)
    def delete_isolated_vdc_network(self, vdc_name, network_name):
        netref = self.get_isolated_network_href(vdc_name, network_name)
        if netref is None:
            return (True, None)
        vcloud_headers = self.vcloud_session.get_vcloud_headers()
        response = self._invoke_api(requests, "delete", netref, headers=vcloud_headers, verify=self.verify)

        if response.status_code == requests.codes.forbidden:
            excep_msg = "Delete_isolated_vdc_network error, network_name:%s" % (network_name)
            raise exceptions.ForbiddenException(excep_msg)
        if response.status_code == requests.codes.bad_request:
            excep_msg = "Delete_isolated_vdc_network bad request, network_name:%s" % (network_name)
            raise exceptions.DeleteException(excep_msg)
        if response.status_code == requests.codes.accepted:
            task = taskType.parseString(response.content, True)
            return (True, task)
        else:
            return (False, response.content)
Ejemplo n.º 23
0
 def delete_disk(self, vdc_name, name, id=None):
     vdc = self.get_vdc(vdc_name)
     refs = self.get_diskRefs(vdc)
     link = []
     if id is not None:
         link = filter(lambda link: link.get_href().endswith('/'+id), refs)
     elif name is not None:
         link = filter(lambda link: link.get_name() == name, refs)
     if len(link) == 1:
         self.response = requests.delete(link[0].get_href(), headers=self.vcloud_session.get_vcloud_headers(), verify=self.verify)
         if self.response.status_code == requests.codes.accepted:
             task = taskType.parseString(self.response.content, True)
             return (True, task)
         else:
             return(False, self.response.content)
     elif len(link) == 0:
         return(False, 'disk not found')
     elif len(link) > 1:
         return(False, 'more than one disks found with that name, use the disk id')
Ejemplo n.º 24
0
def wait_for_task(vca_client, task):
    """
        check status of current task and make request for recheck
        task status in case when we have not well defined state
        (not error and not success)
    """
    status = task.get_status()
    while status != TASK_STATUS_SUCCESS:
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise cfy_exc.NonRecoverableError(
                "Error during task execution: {0}".format(error.get_message()))
        else:
            time.sleep(TASK_RECHECK_TIMEOUT)
            response = requests.get(
                task.get_href(),
                headers=vca_client.vcloud_session.get_vcloud_headers())
            task = taskType.parseString(response.content, True)
            status = task.get_status()
Ejemplo n.º 25
0
def wait_for_task(vca_client, task):
    """
        check status of current task and make request for recheck
        task status in case when we have not well defined state
        (not error and not success)
    """
    status = task.get_status()
    while status != TASK_STATUS_SUCCESS:
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise cfy_exc.NonRecoverableError(
                "Error during task execution: {0}".format(error.get_message()))
        else:
            time.sleep(TASK_RECHECK_TIMEOUT)
            response = requests.get(
                task.get_href(),
                headers=vca_client.vcloud_session.get_vcloud_headers())
            task = taskType.parseString(response.content, True)
            status = task.get_status()
Ejemplo n.º 26
0
 def test_action_vminstance(self, get_vdc_details, get_namebyvappid,
                            connect, get_vapp, block):
     task_resp = xml_resp.task_xml
     vm_id = '05e6047b-6938-4275-8940-22d1ea7245b8'
     # created vdc object
     vdc_xml_resp = xml_resp.vdc_xml_response
     vdc = vdcType.parseString(vdc_xml_resp, True)
     # assumed return value from VIM connector
     get_vdc_details.return_value = vdc
     get_namebyvappid.return_value = 'Test1_vm-69a18104-8413-4cb8-bad7-b5afaec6f9fa'
     connect.return_value = self.vca
     self.vim.vca = self.vim.connect()
     get_vapp.return_value.undeploy.return_value = taskType.parseString(
         task_resp, True)
     block.return_value = True
     # call to VIM connector method
     result = self.vim.action_vminstance(vm_id, {'shutdown': None})
     # assert verified expected and return result from VIM connector
     self.assertEqual(result, None)
Ejemplo n.º 27
0
 def  modify_vm_memory(self, new_size):
     children = self.me.get_Children()
     if children:
         vms = children.get_Vm()
         for vm in vms:
             sections = vm.get_Section()
             virtualHardwareSection = filter(lambda section: section.__class__.__name__== "VirtualHardwareSection_Type", sections)[0]
             items = virtualHardwareSection.get_Item()
             memory = filter(lambda item: item.get_Description().get_valueOf_() == "Memory Size", items)[0]
             href = memory.get_anyAttributes_().get('{http://www.vmware.com/vcloud/v1.5}href')
             en = memory.get_ElementName()
             en.set_valueOf_('%s MB of memory' % new_size)
             memory.set_ElementName(en)
             vq = memory.get_VirtualQuantity()
             vq.set_valueOf_(new_size)
             memory.set_VirtualQuantity(vq)
             weight = memory.get_Weight()
             weight.set_valueOf_(str(int(new_size)*10))
             memory.set_Weight(weight)
             memory_string = CommonUtils.convertPythonObjToStr(memory, 'Memory')
             output = StringIO()
             memory.export(output,
                 0,
                 name_ = 'Item',
                 namespacedef_ = 'xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1" xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"',
                 pretty_print = True)
             body = output.getvalue().\
                 replace('Info msgid=""', "ovf:Info").replace("/Info", "/ovf:Info").\
                 replace("vmw:", "").replace("class:", "rasd:").replace("ResourceType", "rasd:ResourceType")
             response = self._invoke_api(requests, 'put',
                                         href,
                                         headers=self.headers,
                                         data=body,
                                         verify=self.verify)
             if response.status_code == requests.codes.accepted:
                 task = taskType.parseString(response.content, True)
                 return (True, task)
             else:
                 return (False, response.content)
     raise Exception('can\'t find vm')
Ejemplo n.º 28
0
def wait_for_task(vca_client, task):
    TASK_RECHECK_TIMEOUT = 5
    TASK_STATUS_SUCCESS = 'success'
    TASK_STATUS_ERROR = 'error'

    WAIT_TIME_MAX_MINUTES = 30
    MAX_ATTEMPTS = WAIT_TIME_MAX_MINUTES * 60 / TASK_RECHECK_TIMEOUT
    status = task.get_status()
    for attempt in xrange(MAX_ATTEMPTS):
        if status == TASK_STATUS_SUCCESS:
            return
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise RuntimeError("Error during task execution: {0}".format(
                error.get_message()))
        time.sleep(TASK_RECHECK_TIMEOUT)
        response = requests.get(
            task.get_href(),
            headers=vca_client.vcloud_session.get_vcloud_headers(),
            verify=False)
        task = taskType.parseString(response.content, True)
        status = task.get_status()
    raise RuntimeError("Wait for task timeout.")
Ejemplo n.º 29
0
 def block_until_completed(self, task):
     progress = task.get_Progress()
     status = task.get_status()
     rnd = 0
     while status != "success":
         if status == "error":
             error = task.get_Error()
             return False
         else:
             # some task doesn't not report progress
             if progress:
                 pass
             else:
                 rnd += 1
             time.sleep(1)
             self.response = requests.get(task.get_href(), headers=self.vcloud_session.get_vcloud_headers(), verify=self.verify)
             if self.response.status_code == requests.codes.ok:
                 task = taskType.parseString(self.response.content, True)
                 progress = task.get_Progress()
                 status = task.get_status()
             else:
                 return False
     return True
Ejemplo n.º 30
0
def wait_for_task(vca_client, task):
    TASK_RECHECK_TIMEOUT = 5
    TASK_STATUS_SUCCESS = 'success'
    TASK_STATUS_ERROR = 'error'

    WAIT_TIME_MAX_MINUTES = 30
    MAX_ATTEMPTS = WAIT_TIME_MAX_MINUTES * 60 / TASK_RECHECK_TIMEOUT
    status = task.get_status()
    for attempt in xrange(MAX_ATTEMPTS):
        if status == TASK_STATUS_SUCCESS:
            return
        if status == TASK_STATUS_ERROR:
            error = task.get_Error()
            raise RuntimeError(
                "Error during task execution: {0}".format(error.get_message()))
        time.sleep(TASK_RECHECK_TIMEOUT)
        response = requests.get(
            task.get_href(),
            headers=vca_client.vcloud_session.get_vcloud_headers(),
            verify=False)
        task = taskType.parseString(response.content, True)
        status = task.get_status()
    raise RuntimeError("Wait for task timeout.")
    def delete_isolated_vdc_network(self, vdc_name, network_name):
        netref = self.get_isolated_network_href(vdc_name, network_name)
        if netref is None:
            return (True, None)
        vcloud_headers = self.vcloud_session.get_vcloud_headers()
        response = self._invoke_api(requests, 'delete',
                                    netref,
                                    headers=vcloud_headers,
                                    verify=self.verify)

        if response.status_code == requests.codes.forbidden:
            excep_msg = "Delete_isolated_vdc_network error, network_name:%s"\
                % (network_name)
            raise exceptions.ForbiddenException(excep_msg)
        if response.status_code == requests.codes.bad_request:
            excep_msg = "Delete_isolated_vdc_network bad request, network_name:%s"\
                % (network_name)
            raise exceptions.DeleteException(excep_msg)
        if response.status_code == requests.codes.accepted:
            task = taskType.parseString(response.content, True)
            return (True, task)
        else:
            return (False, response.content)
Ejemplo n.º 32
0
 def modify_vm_cpu(self, cpus):
     children = self.me.get_Children()
     if children:
         vms = children.get_Vm()
         for vm in vms:
             sections = vm.get_Section()
             virtualHardwareSection = filter(lambda section: section.__class__.__name__== "VirtualHardwareSection_Type", sections)[0]
             items = virtualHardwareSection.get_Item()
             cpu = filter(lambda item: (item.get_anyAttributes_().get('{http://www.vmware.com/vcloud/v1.5}href') != None and item.get_anyAttributes_().get('{http://www.vmware.com/vcloud/v1.5}href').endswith('/virtualHardwareSection/cpu')), items)[0]
             href = cpu.get_anyAttributes_().get('{http://www.vmware.com/vcloud/v1.5}href')
             en = cpu.get_ElementName()
             en.set_valueOf_('%s virtual CPU(s)' % cpus)
             cpu.set_ElementName(en)
             vq = cpu.get_VirtualQuantity()
             vq.set_valueOf_(cpus)
             cpu.set_VirtualQuantity(vq)
             cpu_string = CommonUtils.convertPythonObjToStr(cpu, 'CPU')
             output = StringIO()
             cpu.export(output,
                 0,
                 name_ = 'Item',
                 namespacedef_ = 'xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1" xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"',
                 pretty_print = True)
             body = output.getvalue().\
                 replace('Info msgid=""', "ovf:Info").replace("/Info", "/ovf:Info").\
                 replace("vmw:", "").replace("class:", "rasd:").replace("ResourceType", "rasd:ResourceType")
             response = self._invoke_api(requests, 'put',
                                         href,
                                         headers=self.headers,
                                         data=body,
                                         verify=self.verify)
             if response.status_code == requests.codes.accepted:
                 task = taskType.parseString(response.content, True)
                 return (True, task)
             else:
                 return (False, response.content)
     raise Exception('can\'t find vm')
Ejemplo n.º 33
0
 def create_or_update_task(self,
                           status,
                           namespace,
                           operation_name,
                           operation_description,
                           owner_href,
                           owner_name,
                           owner_type,
                           user_id,
                           user_name,
                           progress,
                           details,
                           org_id=None,
                           task_id=None):
     if self.vcloud_session:
         o = urlparse(self.vcloud_session.url)
         api_url = '%s://%s%s' % (o.scheme, o.netloc, '/api')
         if progress is None:
             progress_indicator = ''
         else:
             progress_indicator = 'progress="%s"' % progress
         data = """
             <Task
                xmlns="http://www.vmware.com/vcloud/v1.5"
                status="{status}"
                serviceNamespace="{namespace}"
                type="application/vnd.vmware.vcloud.task+xml"
                operation="{operation_description}"
                operationName="{operation_name}"
                {progress_indicator}
                name="task">
                <Owner href="{owner_href}" name="{owner_name}"
                       type="{owner_type}"/>
                <User href="{api_url}/admin/user/{user_id}"
                      name="{user_name}"
                      type="application/vnd.vmware.admin.user+xml"/>
                <Details>"{details}"</Details>
             </Task>
         """.format(status=status,
                    namespace=namespace,
                    operation_description=operation_description,
                    operation_name=operation_name,
                    progress_indicator=progress_indicator,
                    api_url=api_url,
                    details=details,
                    owner_href=owner_href,
                    owner_name=owner_name,
                    owner_type=owner_type,
                    user_id=user_id,
                    user_name=user_name)
         if task_id is None:
             link = '%s/tasksList/%s' % (api_url, org_id)
             self.response = Http.post(
                 link,
                 headers=self.vcloud_session.get_vcloud_headers(),
                 verify=self.verify,
                 logger=self.logger,
                 data=data)
         else:
             link = '%s/task/%s' % (api_url, task_id)
             self.response = Http.put(
                 link,
                 headers=self.vcloud_session.get_vcloud_headers(),
                 verify=self.verify,
                 logger=self.logger,
                 data=data)
         if self.response.status_code == requests.codes.ok:
             return taskType.parseString(self.response.content, True)
         else:
             raise Exception(self.response.status_code)
     return None