# -*- coding: utf-8 -*-

##
# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
# This file is part of openmano
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
# For those usages not covered by the Apache License, Version 2.0 please
# contact with: nfvlabs@tid.es
##

'''
vimconn_vmware implementation an Abstract class in order to interact with VMware  vCloud Director.
mbayramov@vmware.com
'''
import os
import requests


from xml.etree import ElementTree as ET

from pyvcloud import Http
from pyvcloud.vcloudair import VCA
from pyvcloud.schema.vcd.v1_5.schemas.vcloud import sessionType, organizationType, \
    vAppType, organizationListType, vdcType, catalogType, queryRecordViewType, \
    networkType, vcloudType, taskType, diskType, vmsType, vdcTemplateListType, mediaType
from xml.sax.saxutils import escape

import logging
import json
import vimconn
import time
import uuid
import httplib


__author__="Mustafa Bayramov"
__date__ ="$26-Aug-2016 11:09:29$"


#Error variables
HTTP_Bad_Request = 400
HTTP_Unauthorized = 401
HTTP_Not_Found = 404
HTTP_Method_Not_Allowed = 405
HTTP_Request_Timeout = 408
HTTP_Conflict = 409
HTTP_Not_Implemented = 501
HTTP_Service_Unavailable = 503
HTTP_Internal_Server_Error = 500

class vimconnException(Exception):
    '''Common and base class Exception for all vimconnector exceptions'''
    def __init__(self, message, http_code=HTTP_Bad_Request):
        Exception.__init__(self, message)
        self.http_code = http_code

class vimconnConnectionException(vimconnException):
    '''Connectivity error with the VIM'''
    def __init__(self, message, http_code=HTTP_Service_Unavailable):
        vimconnException.__init__(self, message, http_code)

class vimconnUnexpectedResponse(vimconnException):
    '''Get an wrong response from VIM'''
    def __init__(self, message, http_code=HTTP_Service_Unavailable):
        vimconnException.__init__(self, message, http_code)

class vimconnAuthException(vimconnException):
    '''Invalid credentials or authorization to perform this action over the VIM'''
    def __init__(self, message, http_code=HTTP_Unauthorized):
        vimconnException.__init__(self, message, http_code)

class vimconnNotFoundException(vimconnException):
    '''The item is not found at VIM'''
    def __init__(self, message, http_code=HTTP_Not_Found):
        vimconnException.__init__(self, message, http_code)

class vimconnConflictException(vimconnException):
    '''There is a conflict, e.g. more item found than one'''
    def __init__(self, message, http_code=HTTP_Conflict):
        vimconnException.__init__(self, message, http_code)

class vimconnNotImplemented(vimconnException):
    '''The method is not implemented by the connected'''
    def __init__(self, message, http_code=HTTP_Not_Implemented):
        vimconnException.__init__(self, message, http_code)


flavorlist = {}

class vimconnector():
    '''Vmware VIM Connector base class
    '''
    def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level="ERROR", config={}):
        self.id        = uuid
        self.name      = name
        self.url       = url
        self.url_admin = url_admin
        self.tenant_id = tenant_id
        self.tenant_name = tenant_name
        self.user      = user
        self.passwd    = passwd
        self.config    = config
        self.logger = logging.getLogger('openmano.vim.vmware')

#         formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#         ch = logging.StreamHandler()
#         ch.setLevel(log_level)
#         ch.setFormatter(formatter)
#         self.logger.addHandler(ch)
#         self.logger.setLevel( getattr(logging, log_level))

#        self.logger = logging.getLogger('mano.vim.vmware')

        self.logger.debug("Vmware tenant from VIM filter: '%s'", user)
        self.logger.debug("Vmware tenant from VIM filter: '%s'", passwd)

        if not url:
            raise TypeError, 'url param can not be NoneType'

        if not self.url_admin:  #try to use normal url
            self.url_admin = self.url

        self.vcaversion = '5.6'

        print "Calling constructor with following paramters"
        print "          UUID:   {} ".format(uuid)
        print "          name:   {} ".format(name)
        print "     tenant_id:   {} ".format(tenant_id)
        print "     tenant_name: {} ".format(tenant_name)
        print "     url:         {} ".format(url)
        print "     url_admin:   {} ".format(url_admin)
        print "     user:        {} ".format(user)
        print "     passwd:      {} ".format(passwd)
        print "     debug:       {} ".format(log_level)

    def __getitem__(self,index):
        if index=='tenant_id':
            return self.tenant_id
        if index=='tenant_name':
            return self.tenant_name
        elif index=='id':
            return self.id
        elif index=='name':
            return self.name
        elif index=='user':
            return self.user
        elif index=='passwd':
            return self.passwd
        elif index=='url':
            return self.url
        elif index=='url_admin':
            return self.url_admin
        elif index=="config":
            return self.config
        else:
            raise KeyError("Invalid key '%s'" %str(index))

    def __setitem__(self,index, value):
        if index=='tenant_id':
            self.tenant_id = value
        if index=='tenant_name':
            self.tenant_name = value
        elif index=='id':
            self.id = value
        elif index=='name':
            self.name = value
        elif index=='user':
            self.user = value
        elif index=='passwd':
            self.passwd = value
        elif index=='url':
            self.url = value
        elif index=='url_admin':
            self.url_admin = value
        else:
            raise KeyError("Invalid key '%s'" %str(index))

    def connect(self):

        service_type = 'standalone'
        version = '5.6'

        self.logger.debug("Logging in to a VCA '%s'", self.name)

        vca = VCA(host=self.url, username=self.user, service_type=service_type, version=version, verify=False, log=True)
        result = vca.login(password=self.passwd, org=self.name)
        if not result:
            raise KeyError("Can't connect to a vCloud director.")
        result = vca.login(token=vca.token, org=self.name, org_url=vca.vcloud_session.org_url)
        if result is True:
            self.logger.debug("Successfully logged to a VCA '%s'", self.name)

        # vca = VCA(host='172.16.254.206', username=self.user, service_type='standalone', version='5.6', verify=False, log=True)
        # vca.login(password=self.passwd, org=self.name)
        # vca.login(token=vca.token, org=self.name, org_url=vca.vcloud_session.org_url)

        # if not result:
        #     result = vca.login(token=vca.token, org=self.name, org_url=vca.vcloud_session.org_url)
        #     if not result:
        #         raise KeyError("Can't connect to a vcloud director")
        #     else:
        #         print "Logged to VCA via existing token"
        # else:
        #     print "Logged to VCA"

        return vca


    def new_tenant(self,tenant_name,tenant_description):
        '''Adds a new tenant to VIM with this name and description,
        returns the tenant identifier'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def delete_tenant(self,tenant_id,):
        '''Delete a tenant from VIM'''
        '''Returns the tenant identifier'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def get_tenant_list(self, filter_dict={}):
        '''Obtain tenants of VIM
        filter_dict can contain the following keys:
            name: filter by tenant name
            id: filter by tenant uuid/id
            <other VIM specific>
        Returns the tenant list of dictionaries: 
            [{'name':'<name>, 'id':'<id>, ...}, ...]
        '''
        raise vimconnNotImplemented( "Should have implemented this" )

    def new_network(self,net_name, net_type, ip_profile=None, shared=False):
        '''Adds a tenant network to VIM
            net_name is the name
            net_type can be 'bridge','data'.'ptp'.  TODO: this need to be revised
            ip_profile is a dict containing the IP parameters of the network 
            shared is a boolean
        Returns the network identifier'''

        self.logger.debug("Vmware tenant from VIM filter: '%s'", net_name)
        self.logger.debug("Vmware tenant from VIM filter: '%s'", net_type)
        self.logger.debug("Vmware tenant from VIM filter: '%s'", ip_profile)
        self.logger.debug("Vmware tenant from VIM filter: '%s'", shared)

        raise vimconnNotImplemented( "Should have implemented this" )

    def get_network_list(self, filter_dict={}):
        '''Obtain tenant networks of VIM
        Filter_dict can be:
            name: network name
            id: network uuid
            shared: boolean
            tenant_id: tenant
            admin_state_up: boolean
            status: 'ACTIVE'
        Returns the network list of dictionaries:
            [{<the fields at Filter_dict plus some VIM specific>}, ...]
            List can be empty
        '''

        vca = self.connect()
        if not vca:
            raise vimconn.vimconnConnectionException("self.connect() is failed")

        vdc = vca.get_vdc(self.tenant_name)
        vdcid = vdc.get_id().split(":")

        networks = vca.get_networks(vdc.get_name())
        network_list = []
        for network in networks:
            filter_dict = {}
            netid = network.get_id().split(":")
            self.logger.debug ("Adding  {} to a list".format(netid[3]))
            self.logger.debug ("VDC ID  {} to a list".format(vdcid[3]))
            self.logger.debug ("Network {} to a list".format(network.get_name()))

            filter_dict["name"] = network.get_name()
            filter_dict["id"] = netid[3]
            filter_dict["shared"] = network.get_IsShared()
            filter_dict["tenant_id"] = vdcid[3]
            if network.get_status() == 1:
                filter_dict["admin_state_up"] = True
            else:
                filter_dict["admin_state_up"] = False
            filter_dict["status"] = "ACTIVE"
            filter_dict["type"] = "bridge"
            network_list.append(filter_dict)

        self.logger.debug("Returning {}".format(network_list))
        return network_list

    def get_network(self, net_id):
        '''Obtain network details of net_id VIM network'
           Return a dict with  the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def delete_network(self, net_id):
        '''Deletes a tenant network from VIM, provide the network id.
        Returns the network identifier or raise an exception'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def refresh_nets_status(self, net_list):
        '''Get the status of the networks
           Params: the list of network identifiers
           Returns a dictionary with:
                net_id:         #VIM id of this network
                    status:     #Mandatory. Text with one of:
                                #  DELETED (not found at vim)
                                #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...) 
                                #  OTHER (Vim reported other status not understood)
                                #  ERROR (VIM indicates an ERROR status)
                                #  ACTIVE, INACTIVE, DOWN (admin down), 
                                #  BUILD (on building process)
                                #
                    error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR 
                    vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)

        '''
        raise vimconnNotImplemented( "Should have implemented this" )

    def get_flavor(self, flavor_id):
        '''Obtain flavor details from the  VIM
            Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
        '''

        print " get_flavor contains {}".format(flavor_id)

        vca = self.connect()
        if not vca:
            raise vimconn.vimconnConnectionException("self.connect() is failed.")

    def new_flavor(self, flavor_data):
        '''Adds a tenant flavor to VIM
            flavor_data contains a dictionary with information, keys:
                name: flavor name
                ram: memory (cloud type) in MBytes
                vpcus: cpus (cloud type)
                extended: EPA parameters
                  - numas: #items requested in same NUMA
                        memory: number of 1G huge pages memory
                        paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
                        interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
                          - name: interface name
                            dedicated: yes|no|yes:sriov;  for PT, SRIOV or only one SRIOV for the physical NIC
                            bandwidth: X Gbps; requested guarantee bandwidth
                            vpci: requested virtual PCI address   
                disk: disk size
                is_public:
                       
                
                 #TODO to concrete
        Returns the flavor identifier'''

        flavor_uuid = uuid.uuid4()
        flavorlist[flavor_uuid] = flavor_data

        print " new_flavor contains  {}".format(flavor_data)
        print " flavor list contains {}".format(flavorlist)

        return flavor_uuid

    def delete_flavor(self, flavor_id):
        '''Deletes a tenant flavor from VIM identify by its id
        Returns the used id or raise an exception'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def new_image(self,image_dict):
        '''
        Adds a tenant image to VIM
        Returns:
            200, image-id        if the image is created
            <0, message          if there is an error
        '''

        print " ################################################################### "
        print " new_image contains  {}".format(image_dict)
        print " ################################################################### "


    def delete_image(self, image_id):
        '''Deletes a tenant image from VIM'''
        '''Returns the HTTP response code and a message indicating details of the success or fail'''

        print " ################################################################### "
        print " delete_image contains  {}".format(image_id)
        print " ################################################################### "

        raise vimconnNotImplemented( "Should have implemented this" )

    def catalog_exists(self, catalog_name, catalogs):
        for catalog in catalogs:
            if catalog.name == catalog_name:
                return True
        return False

    def create_vimcatalog(self, vca, catalog_name):
        """Create Catalog entry in VIM"""
        task = vca.create_catalog(catalog_name, catalog_name)
        result = vca.block_until_completed(task)
        if not result:
            return False
        catalogs = vca.get_catalogs()
        return self.catalog_exists(catalog_name, catalogs)


    def upload_ovf(self, vca, catalog_name, item_name, media_file_name, description='', display_progress=False,
                   chunk_bytes=128 * 1024):
        """
        Uploads a OVF file to a vCloud catalog

        :param catalog_name: (str): The name of the catalog to upload the media.
        :param item_name: (str): The name of the media file in the catalog.
        :param media_file_name: (str): The name of the local media file to upload.
        :return: (bool) True if the media file was successfully uploaded, false otherwise.
        """
        os.path.isfile(media_file_name)
        statinfo = os.stat(media_file_name)
        statinfo.st_size

        #  find a catalog entry where we upload OVF.
        #  create vApp Template and check the status if vCD able to read OVF it will respond with appropirate
        #  status change.
        #  if VCD can parse OVF we upload VMDK file
        for catalog in vca.get_catalogs():
            if catalog_name != catalog.name:
                continue
            link = filter(lambda link: link.get_type() == "application/vnd.vmware.vcloud.media+xml" and
                                       link.get_rel() == 'add', catalog.get_Link())
            assert len(link) == 1
            data = """
            <UploadVAppTemplateParams name="%s Template" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>%s vApp Template</Description></UploadVAppTemplateParams>
            """ % (escape(item_name), escape(description))
            headers = vca.vcloud_session.get_vcloud_headers()
            headers['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
            response = Http.post(link[0].get_href(), headers=headers, data=data, verify=vca.verify, logger=self.logger)
            if response.status_code == requests.codes.created:
                catalogItem = ET.fromstring(response.content)
                entity = [child for child in catalogItem if
                          child.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
                href = entity.get('href')
                template = href
                response = Http.get(href, headers=vca.vcloud_session.get_vcloud_headers(),
                                    verify=vca.verify, logger=self.logger)

                if response.status_code == requests.codes.ok:
                    media = mediaType.parseString(response.content, True)
                    link = filter(lambda link: link.get_rel() == 'upload:default', media.get_Files().get_File()[0].get_Link())[0]
                    headers = vca.vcloud_session.get_vcloud_headers()
                    headers['Content-Type'] = 'Content-Type text/xml'
                    response = Http.put(link.get_href(), data=open(media_file_name, 'rb'), headers=headers, verify=vca.verify,logger=self.logger)
                    if response.status_code != requests.codes.ok:
                        self.logger.debug("Failed create vApp template for catalog name {} and image {}".format(catalog_name, media_file_name))
                        return False

                time.sleep(5)

                self.logger.debug("Failed create vApp template for catalog name {} and image {}".
                                  format(catalog_name, media_file_name))

                # uploading VMDK file
                # check status of OVF upload
                response = Http.get(template, headers=vca.vcloud_session.get_vcloud_headers(), verify=vca.verify, logger=self.logger)
                if response.status_code == requests.codes.ok:
                    media = mediaType.parseString(response.content, True)
                    link = filter(lambda link: link.get_rel() == 'upload:default', media.get_Files().get_File()[0].get_Link())[0]

                    # The OVF file and VMDK must be in a same directory
                    head, tail = os.path.split(media_file_name)
                    filevmdk = head + '/' + os.path.basename(link.get_href())

                    os.path.isfile(filevmdk)
                    statinfo = os.stat(filevmdk)

                    # TODO debug output remove it
                    #print media.get_Files().get_File()[0].get_Link()[0].get_href()
                    #print media.get_Files().get_File()[1].get_Link()[0].get_href()
                    #print link.get_href()

                    # in case first element is pointer to OVF.
                    hrefvmdk = link.get_href().replace("descriptor.ovf","Cirros-disk1.vmdk")

                    f = open(filevmdk, 'rb')
                    bytes_transferred = 0
                    while bytes_transferred < statinfo.st_size:
                        my_bytes = f.read(chunk_bytes)
                        if len(my_bytes) <= chunk_bytes:
                            headers = vca.vcloud_session.get_vcloud_headers()
                            headers['Content-Range'] = 'bytes %s-%s/%s' % (bytes_transferred, len(my_bytes) - 1, statinfo.st_size)
                            headers['Content-Length'] = str(len(my_bytes))
                            response = Http.put(hrefvmdk, headers=headers, data=my_bytes, verify=vca.verify,logger=None)
                            if response.status_code == requests.codes.ok:
                                bytes_transferred += len(my_bytes)
                                self.logger.debug('transferred %s of %s bytes' % (str(bytes_transferred),
                                                                                  str(statinfo.st_size)))
                            else:
                                self.logger.debug('file upload failed with error: [%s] %s' % (response.status_code,
                                                                                              response.content))
                                return False
                    f.close()
                    return True
                else:
                    self.logger.debug("Failed retrieve vApp template for catalog name {} for OVF {}".
                                      format(catalog_name, media_file_name))
                    return False

        self.logger.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name, media_file_name))
        return False

    def upload_vimimage(self,vca, catalog_name, media_name, medial_file_name):
        """Upload media file"""
        return self.upload_ovf(vca, catalog_name, media_name.split(".")[0], medial_file_name, medial_file_name, True)

    def get_catalogid(self, catalog_name, catalogs):
        for catalog in catalogs:
            if catalog.name == catalog_name:
                print catalog.name
                catalog_id = catalog.get_id().split(":")
                return catalog_id[3]
        return None

    def get_catalogbyid(self, catalog_id, catalogs):
        for catalog in catalogs:
            catalogid = catalog.get_id().split(":")[3]
            if catalogid == catalog_id:
                return catalog.name
        return None

    def get_image_id_from_path(self, path):
        '''Get the image id from image path in the VIM database'''
        '''Returns:
             0,"Image not found"   if there are no images with that path
             1,image-id            if there is one image with that path
             <0,message            if there was an error (Image not found, error contacting VIM, more than 1 image with that path, etc.) 
        '''

        vca = self.connect()
        if not vca:
            raise vimconn.vimconnConnectionException("self.connect() is failed")

        self.logger.debug("get_image_id_from_path path {}".format(path))

        dirpath, filename = os.path.split(path)
        flname, file_extension = os.path.splitext(path)
        if file_extension != '.ovf':
            self.logger.debug("Wrong file extension {}".format(file_extension))
            return -1, "Wrong container.  vCloud director supports only OVF."
        catalog_name = os.path.splitext(filename)[0]

        self.logger.debug("File name {} Catalog Name {} file path {}".format(filename, catalog_name, path))
        self.logger.debug("Catalog name {}".format(catalog_name))

        catalogs = vca.get_catalogs()
        if len(catalogs) == 0:
            self.logger.info("Creating new catalog entry {} in vcloud director".format(catalog_name))
            result = self.create_vimcatalog(vca, catalog_name)
            if not result:
                return -1, "Failed create new catalog {} ".format(catalog_name)
            result = self.upload_vimimage(vca, catalog_name, filename, path)
            if not result:
                return -1, "Failed create vApp template for catalog {} ".format(catalog_name)
            return self.get_catalogid(catalog_name, vca.get_catalogs())
        else:
            for catalog in catalogs:
                # search for existing catalog if we find same name we return ID
                # TODO optimize this
                if catalog.name == catalog_name:
                    self.logger.debug("Found existing catalog entry for {} catalog id {}".format(catalog_name, self.get_catalogid(catalog_name, catalogs)))
                    return self.get_catalogid(catalog_name, vca.get_catalogs())

        # if we didn't find existing catalog we create a new one.
        self.logger.debug("Creating new catalog entry".format(catalog_name))
        result = self.create_vimcatalog(vca, catalog_name)
        if not result:
            return -1, "Failed create new catalog {} ".format(catalog_name)
        result = self.upload_vimimage(vca, catalog_name, filename, path)
        if not result:
            return -1, "Failed create vApp template for catalog {} ".format(catalog_name)

        return self.get_catalogid(catalog_name, vca.get_catalogs())

    def get_vappid(self, vdc, vapp_name):
        """ Take vdc object and vApp name and returns vapp uuid or None
        """
        #UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf

        try:
            refs = filter(lambda ref: ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml',
                      vdc.ResourceEntities.ResourceEntity)

            if len(refs) == 1:
                return refs[0].href.split("vapp")[1][1:]
        except:
            return None
        return None

    def get_vappbyid(self, vdc, vapp_id):
        refs = filter(lambda ref: ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml',
                      vdc.ResourceEntities.ResourceEntity)
        for ref in refs:
            print ref.href

        if len(refs) == 1:
            return refs[0].href.split("vapp")[1][1:]

    def new_vminstance(self,name,description,start,image_id,flavor_id,net_list,cloud_config=None):
        """Adds a VM instance to VIM
        Params:
            start: indicates if VM must start or boot in pause mode. Ignored
            image_id,flavor_id: image and flavor uuid
            net_list: list of interfaces, each one is a dictionary with:
                name:
                net_id: network uuid to connect
                vpci: virtual vcpi to assign
                model: interface model, virtio, e2000, ...
                mac_address:
                use: 'data', 'bridge',  'mgmt'
                type: 'virtual', 'PF', 'VF', 'VFnotShared'
                vim_id: filled/added by this function
                cloud_config: can be a text script to be passed directly to cloud-init,
                    or an object to inject users and ssh keys with format:
                        key-pairs: [] list of keys to install to the default user
                        users: [{ name, key-pairs: []}] list of users to add with their key-pair
                #TODO ip, security groups
        Returns >=0, the instance identifier
                <0, error_text
        """

        self.logger.info("Creating new instance for entry".format(name))
        self.logger.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {}".
                          format(description, start, image_id, flavor_id, net_list, cloud_config))
        vca = self.connect()
        if not vca:
            raise vimconn.vimconnConnectionException("self.connect() is failed.")

        # TODO following attribute need be featched from flavor / OVF file must contain same data.
        # task = self.vca.create_vapp(vdc_name, vapp_name, template, catalog,
        #                             vm_name=vm_name,
        #                             vm_cpus=cpu,
        #                             vm_memory=memory)
        #

        catalogs = vca.get_catalogs()
        #image upload creates template name as catalog name space Template.
        templateName = self.get_catalogbyid(image_id, catalogs) + ' Template'
        task = vca.create_vapp(self.tenant_name, name, templateName, self.get_catalogbyid(image_id,catalogs), vm_name=name)
        if task is False:
            return -1, " Failed deploy vApp {}".format(name)

        result = vca.block_until_completed(task)
        if result:
            vappID = self.get_vappid(vca.get_vdc(self.tenant_name), name)
            if vappID is None:
                return -1, " Failed featch UUID for vApp {}".format(name)
            else:
                return vappID

        return -1, " Failed create vApp {}".format(name)

    def get_vminstance(self,vm_id):
        '''Returns the VM instance information from VIM'''

        vca = self.connect()
        if not vca:
            raise vimconn.vimconnConnectionException("self.connect() is failed.")


        raise vimconnNotImplemented( "Should have implemented this" )

    def delete_vminstance(self, vm_id):
        '''Removes a VM instance from VIM'''
        '''Returns the instance identifier'''

        print " ###### {} ".format(vm_id)

        vca = self.connect()
        if not vca:
            raise vimconn.vimconnConnectionException("self.connect() is failed.")

        thevdc = vca.get_vdc(self.tenant_name)
        self.get_vappid(vca.get_vdc(self.tenant_name), name)


    def refresh_vms_status(self, vm_list):
        '''Get the status of the virtual machines and their interfaces/ports
           Params: the list of VM identifiers
           Returns a dictionary with:
                vm_id:          #VIM id of this Virtual Machine
                    status:     #Mandatory. Text with one of:
                                #  DELETED (not found at vim)
                                #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...) 
                                #  OTHER (Vim reported other status not understood)
                                #  ERROR (VIM indicates an ERROR status)
                                #  ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running), 
                                #  CREATING (on building process), ERROR
                                #  ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
                                #
                    error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR 
                    vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
                    interfaces:
                     -  vim_info:         #Text with plain information obtained from vim (yaml.safe_dump)
                        mac_address:      #Text format XX:XX:XX:XX:XX:XX
                        vim_net_id:       #network id where this interface is connected
                        vim_interface_id: #interface/port VIM id
                        ip_address:       #null, or text with IPv4, IPv6 address
        '''
        raise vimconnNotImplemented( "Should have implemented this" )

    def action_vminstance(self, vm_id, action_dict):
        '''Send and action over a VM instance from VIM
        Returns the vm_id if the action was successfully sent to the VIM'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def get_vminstance_console(self,vm_id, console_type="vnc"):
        '''
        Get a console for the virtual machine
        Params:
            vm_id: uuid of the VM
            console_type, can be:
                "novnc" (by default), "xvpvnc" for VNC types, 
                "rdp-html5" for RDP types, "spice-html5" for SPICE types
        Returns dict with the console parameters:
                protocol: ssh, ftp, http, https, ...
                server:   usually ip address 
                port:     the http, ssh, ... port 
                suffix:   extra text, e.g. the http path and query string   
        '''
        raise vimconnNotImplemented( "Should have implemented this" )

#NOT USED METHODS in current version

    def host_vim2gui(self, host, server_dict):
        '''Transform host dictionary from VIM format to GUI format,
        and append to the server_dict
        '''
        raise vimconnNotImplemented( "Should have implemented this" )

    def get_hosts_info(self):
        '''Get the information of deployed hosts
        Returns the hosts content'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def get_hosts(self, vim_tenant):
        '''Get the hosts and deployed instances
        Returns the hosts content'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def get_processor_rankings(self):
        '''Get the processor rankings in the VIM database'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def new_host(self, host_data):
        '''Adds a new host to VIM'''
        '''Returns status code of the VIM response'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def new_external_port(self, port_data):
        '''Adds a external port to VIM'''
        '''Returns the port identifier'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def new_external_network(self,net_name,net_type):
        '''Adds a external network to VIM (shared)'''
        '''Returns the network identifier'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def connect_port_network(self, port_id, network_id, admin=False):
        '''Connects a external port to a network'''
        '''Returns status code of the VIM response'''
        raise vimconnNotImplemented( "Should have implemented this" )

    def new_vminstancefromJSON(self, vm_data):
        '''Adds a VM instance to VIM'''
        '''Returns the instance identifier'''
        raise vimconnNotImplemented( "Should have implemented this" )