def __init__(self, svc_mon, vnc_lib, config_section):
     # Loadbalancer
     self._vnc_lib = vnc_lib
     self._svc_mon = svc_mon
     self._pool_driver = {}
     self._args = config_section
     self._loadbalancer_driver = {}
     # create default service appliance set
     self._create_default_service_appliance_set("opencontrail", 
       "svc_monitor.services.loadbalancer.drivers.ha_proxy.driver.OpencontrailLoadbalancerDriver")
     self._default_provider = "opencontrail"
     self.lb_db = LBDB(config_section)
     self.lb_db.add_logger(self._svc_mon.logger)
     self.lb_db.init_database()
 def __init__(self, svc_mon, vnc_lib, config_section):
     # Loadbalancer
     self._vnc_lib = vnc_lib
     self._svc_mon = svc_mon
     self._pool_driver = {}
     self._args = config_section
     self._loadbalancer_driver = {}
     # create default service appliance set
     self._create_default_service_appliance_set("opencontrail", 
       "svc_monitor.services.loadbalancer.drivers.ha_proxy.driver.OpencontrailLoadbalancerDriver")
     self._default_provider = "opencontrail"
     self.lb_db = LBDB(config_section)
     self.lb_db.add_logger(self._svc_mon.logger)
     self.lb_db.init_database()
class LoadbalancerAgent(object):

    def __init__(self, svc_mon, vnc_lib, config_section):
        # Loadbalancer
        self._vnc_lib = vnc_lib
        self._svc_mon = svc_mon
        self._pool_driver = {}
        self._args = config_section
        self._loadbalancer_driver = {}
        # create default service appliance set
        self._create_default_service_appliance_set("opencontrail", 
          "svc_monitor.services.loadbalancer.drivers.ha_proxy.driver.OpencontrailLoadbalancerDriver")
        self._default_provider = "opencontrail"
        self.lb_db = LBDB(config_section)
        self.lb_db.add_logger(self._svc_mon.logger)
        self.lb_db.init_database()
    # end __init__

    # create default loadbalancer driver
    def _create_default_service_appliance_set(self, sa_set_name, driver_name):
        default_gsc_name = "default-global-system-config"
        default_gsc_fq_name = [default_gsc_name]
        sa_set_fq_name = [default_gsc_name, sa_set_name]

        try:
            sa_set_obj = self._vnc_lib.service_appliance_set_read(fq_name=sa_set_fq_name)
            sa_set_uuid = sa_set_obj.uuid
            return
        except vnc_exc.NoIdError:
            gsc_obj = self._vnc_lib.global_system_config_read(fq_name=default_gsc_fq_name)
            sa_set_obj = ServiceApplianceSet(sa_set_name, gsc_obj)
            sa_set_obj.set_service_appliance_driver(driver_name)
            sa_set_uuid = self._vnc_lib.service_appliance_set_create(sa_set_obj)

    def load_drivers(self):
        for sas in ServiceApplianceSetSM.values():
            if sas.driver:
                config = self._args.config_sections
                config.add_section(sas.name)
                for kvp in sas.kvpairs or []:
                    config.set(sas.name, kvp['key'], kvp['value'])
                if sas.ha_mode:
                    config.set(sas.name, 'ha_mode', str(sas.ha_mode))
                for sa in sas.service_appliances or []:
                    saobj = ServiceApplianceSM.get(sa)
                    config.set(sas.name, 'device_ip', saobj.ip_address)
                    config.set(sas.name, 'user',
                               saobj.user_credential['username'])
                    config.set(sas.name, 'password',
                               saobj.user_credential['password'])
                self._loadbalancer_driver[sas.name] = \
                       importutils.import_object(sas.driver, sas.name,
                           self._svc_mon, self._vnc_lib, self.lb_db, self._args)
    # end load_drivers

    def audit_lb_pools(self):
        for pool_id, config_data, driver_data in self.lb_db.pool_list():
            if LoadbalancerPoolSM.get(pool_id):
                continue
            # Delete the pool from the driver
            driver = self._get_driver_for_provider(config_data['provider'])
            driver.delete_pool(config_data)
            self.lb_db.pool_remove(pool_id)

    def load_driver(self, sas):
        if sas.name in self._loadbalancer_driver:
            return
        if sas.driver:
            config = self._args.config_sections
            config.add_section(sas.name)
            for kvp in sas.kvpairs or []:
                config.set(sas.name, kvp['key'], kvp['value'])
            if sas.ha_mode:
                config.set(sas.name, 'ha_mode', sas.ha_mode)
            for sa in sas.service_appliances or []:
                saobj = ServiceApplianceSet.get(sa)
                config.set(sas.name, 'device_ip', saobj.ip_address)
                config.set(sas.name, 'user', saobj.user_credential['username'])
                config.set(sas.name, 'password',
                           saobj.user_credential['password'])
            self._loadbalancer_driver[sas.name] = \
                       importutils.import_object(sas.driver, sas.name,
                          self._svc_mon, self._vnc_lib, self.lb_db, self._args)
    # end load_driver

    def unload_driver(self, sas):
        if sas.name not in self._loadbalancer_driver:
            return
        del(self._loadbalancer_driver[sas.name])
    # end unload_driver

    def _get_driver_for_provider(self, provider_name):
        return self._loadbalancer_driver[provider_name]
    # end _get_driver_for_provider

    def _get_driver_for_pool(self, pool_id, provider=None):
        if not pool_id:
            return self.drivers[self._default_provider]
        if pool_id in self._pool_driver:
            return self._pool_driver[pool_id]
        if not provider:
            pool = LoadbalancerPoolSM.get(pool_id)
            provider = pool.provider
        driver = self._get_driver_for_provider(provider)
        self._pool_driver[pool_id] = driver
        return driver
    # end _get_driver_for_pool

    # Loadbalancer
    def loadbalancer_pool_add(self, pool):
        p = self.loadbalancer_pool_get_reqdict(pool)
        driver = self._get_driver_for_pool(p['id'], p['provider'])
        try:
            if not pool.last_sent:
                driver.create_pool(p)
            #elif p != pool.last_sent:
            else:
                driver.update_pool(pool.last_sent, p)
        except Exception as ex:
            pass
        self.lb_db.pool_config_insert(p['id'], p)
        return p
    # end loadbalancer_pool_add

    def loadbalancer_member_add(self, member):
        m = self.loadbalancer_member_get_reqdict(member)
        driver = self._get_driver_for_pool(m['pool_id'])
        try:
            if not member.last_sent:
                driver.create_member(m)
            elif m != member.last_sent:
                driver.update_member(member.last_sent, m)
        except Exception as ex:
            pass
        return m
    # end loadbalancer_member_add

    def virtual_ip_add(self, vip):
        v = self.virtual_ip_get_reqdict(vip)
        driver = self._get_driver_for_pool(v['pool_id'])
        try:
            if not vip.last_sent:
                driver.create_vip(v)
            elif v != vip.last_sent:
                driver.update_vip(vip.last_sent, v)
        except Exception as ex:
            pass
        return v
    # end  virtual_ip_add

    def delete_virtual_ip(self, obj):
        v = obj.last_sent
        driver = self._get_driver_for_pool(v['pool_id'])
        try:
            driver.delete_vip(v)
        except Exception as ex:
            pass
    # end delete_virtual_ip

    def delete_loadbalancer_member(self, obj):
        m = obj.last_sent
        driver = self._get_driver_for_pool(m['pool_id'])
        try:
            driver.delete_member(m)
        except Exception as ex:
            pass
    # end delete_loadbalancer_member

    def delete_loadbalancer_pool(self, obj):
        p = obj.last_sent
        driver = self._get_driver_for_pool(p['id'])
        try:
            driver.delete_pool(p)
        except Exception as ex:
            pass
        self.lb_db.pool_remove(p['id'])
    # end delete_loadbalancer_pool

    def update_hm(self, obj):
        hm = self.hm_get_reqdict(obj)
        current_pools = hm['pools'] or []
        old_pools = []
        if obj.last_sent:
            old_pools = hm['pools'] or []
 
        set_current_pools = set()
        set_old_pools = set()
        for i in current_pools:
            set_current_pools.add(i['pool_id'])
        for i in old_pools: 
            set_old_pools.add(i['pool_id'])
        update_pools = set_current_pools & set_old_pools
        delete_pools = set_old_pools - set_current_pools
        add_pools = set_current_pools - set_old_pools
        try:
            for pool in add_pools:
                driver = self._get_driver_for_pool(pool)
                driver.create_pool_health_monitor(hm, pool)
            for pool in delete_pools:
                driver = self._get_driver_for_pool(pool)
                driver.delete_pool_health_monitor(hm, pool)
            for pool in update_pools:
                driver = self._get_driver_for_pool(pool)
                driver.update_health_monitor(obj.last_sent, 
                                         hm, pool)
        except Exception as ex:
            pass
    # end update_hm

    def _get_vip_pool_id(self, vip):
        pool_refs = vip.loadbalancer_pool
        if pool_refs is None:
            return None
        return pool_refs
    # end _get_vip_pool_id

    def _get_interface_params(self, vip, props):
        port_id = vip.virtual_machine_interface
        if port_id is None:
            return None

        if not props['address']:
            vmi = VirtualMachineInterfaceSM.get(port_id)
            ip_refs = vmi.instance_ip
            if ip_refs:
                iip = InstanceIpSM.get(ip_refs)
                props['address'] = iip.address

        return port_id
    # end _get_interface_params

    def virtual_ip_get_reqdict(self, vip):
        props = vip.params
        port_id = self._get_interface_params(vip, props)

        res = {'id': vip.uuid,
               'tenant_id': vip.parent_uuid.replace('-', ''),
               'name': vip.display_name,
               'description': self._get_object_description(vip),
               'subnet_id': props['subnet_id'],
               'address': props['address'],
               'port_id': port_id,
               'protocol_port': props['protocol_port'],
               'protocol': props['protocol'],
               'pool_id': self._get_vip_pool_id(vip),
               'session_persistence': None,
               'connection_limit': props['connection_limit'],
               'admin_state_up': props['admin_state'],
               'status': self._get_object_status(vip)}

        if props['persistence_type']:
            sp = {'type': props['persistence_type']}
            if props['persistence_type'] == 'APP_COOKIE':
                sp['cookie_name'] = props['persistence_cookie_name']
            res['session_persistence'] = sp

        return res;
    # end virtual_ip_get_reqdict

    _loadbalancer_health_type_mapping = {
        'admin_state': 'admin_state_up',
        'monitor_type': 'type',
        'delay': 'delay',
        'timeout': 'timeout',
        'max_retries': 'max_retries',
        'http_method': 'http_method',
        'url_path': 'url_path',
        'expected_codes': 'expected_codes'
    }

    def hm_get_reqdict(self, health_monitor):
        res = {'id': health_monitor.uuid,
               'tenant_id': health_monitor.parent_uuid.replace('-', ''),
               'status': self._get_object_status(health_monitor)}

        props = health_monitor.params
        for key, mapping in self._loadbalancer_health_type_mapping.iteritems():
            value = props[key]
            if value is not None:
                res[mapping] = value

        pool_ids = []
        pool_back_refs = health_monitor.loadbalancer_pools
        for pool_back_ref in pool_back_refs or []:
            pool_id = {}
            pool_id['pool_id'] = pool_back_ref
            pool_ids.append(pool_id)
        res['pools'] = pool_ids

        return res
    # end hm_get_reqdict

    _loadbalancer_member_type_mapping = {
        'admin_state': 'admin_state_up',
        'status': 'status',
        'protocol_port': 'protocol_port',
        'weight': 'weight',
        'address': 'address',
    }

    def loadbalancer_member_get_reqdict(self, member):
        res = {'id': member.uuid,
               'pool_id': member.loadbalancer_pool,
               'status': self._get_object_status(member)}

        pool = LoadbalancerPoolSM.get(member.loadbalancer_pool)
        res['tenant_id'] = pool.parent_uuid.replace('-', '')

        props = member.params
        for key, mapping in self._loadbalancer_member_type_mapping.iteritems():
            value = props[key]
            if value is not None:
                res[mapping] = value

        return res
    # end loadbalancer_member_get_reqdict

    _loadbalancer_pool_type_mapping = {
        'admin_state': 'admin_state_up',
        'protocol': 'protocol',
        'loadbalancer_method': 'lb_method',
        'subnet_id': 'subnet_id'
    }

    def _get_object_description(self, obj):
        id_perms = obj.id_perms
        if id_perms is None:
            return None
        return id_perms['description']
    # end _get_object_description

    def _get_object_status(self, obj):
        id_perms = obj.id_perms
        if id_perms and id_perms['enable']:
            return "ACTIVE"
        return "PENDING_DELETE"
    # end _get_object_status

    def loadbalancer_pool_get_reqdict(self, pool):
        res = {
            'id': pool.uuid,
            'tenant_id': pool.parent_uuid.replace('-', ''),
            'name': pool.display_name,
            'description': self._get_object_description(pool),
            'status': self._get_object_status(pool),
        }

        props = pool.params
        for key, mapping in self._loadbalancer_pool_type_mapping.iteritems():
            value = props[key]
            if value is not None:
                res[mapping] = value

        # provider
        res['provider'] = pool.provider

        # vip_id
        res['vip_id'] = None
        vip_refs = pool.virtual_ip
        if vip_refs is not None:
            res['vip_id'] = vip_refs

        # members
        res['members'] = list(pool.members)

        # health_monitors
        res['health_monitors'] = list(pool.loadbalancer_healthmonitors)

        # TODO: health_monitor_status
        res['health_monitors_status'] = []
        return res
class LoadbalancerAgent(object):

    def __init__(self, svc_mon, vnc_lib, config_section):
        # Loadbalancer
        self._vnc_lib = vnc_lib
        self._svc_mon = svc_mon
        self._pool_driver = {}
        self._args = config_section
        self._loadbalancer_driver = {}
        # create default service appliance set
        self._create_default_service_appliance_set("opencontrail", 
          "svc_monitor.services.loadbalancer.drivers.ha_proxy.driver.OpencontrailLoadbalancerDriver")
        self._default_provider = "opencontrail"
        self.lb_db = LBDB(config_section)
        self.lb_db.add_logger(self._svc_mon.logger)
        self.lb_db.init_database()
    # end __init__

    # create default loadbalancer driver
    def _create_default_service_appliance_set(self, sa_set_name, driver_name):
        default_gsc_name = "default-global-system-config"
        default_gsc_fq_name = [default_gsc_name]
        sa_set_fq_name = [default_gsc_name, sa_set_name]

        try:
            sa_set_obj = self._vnc_lib.service_appliance_set_read(fq_name=sa_set_fq_name)
            sa_set_uuid = sa_set_obj.uuid
            return
        except vnc_exc.NoIdError:
            gsc_obj = self._vnc_lib.global_system_config_read(fq_name=default_gsc_fq_name)
            sa_set_obj = ServiceApplianceSet(sa_set_name, gsc_obj)
            sa_set_obj.set_service_appliance_driver(driver_name)
            sa_set_uuid = self._vnc_lib.service_appliance_set_create(sa_set_obj)

    def load_drivers(self):
        for sas in ServiceApplianceSetSM.values():
            if sas.driver:
                config = self._args.config_sections
                config.add_section(sas.name)
                for kvp in sas.kvpairs or []:
                    config.set(sas.name, kvp['key'], kvp['value'])
                if sas.ha_mode:
                    config.set(sas.name, 'ha_mode', str(sas.ha_mode))
                for sa in sas.service_appliances or []:
                    saobj = ServiceApplianceSM.get(sa)
                    config.set(sas.name, 'device_ip', saobj.ip_address)
                    config.set(sas.name, 'user',
                               saobj.user_credential['username'])
                    config.set(sas.name, 'password',
                               saobj.user_credential['password'])
                self._loadbalancer_driver[sas.name] = \
                       importutils.import_object(sas.driver, sas.name,
                           self._svc_mon, self._vnc_lib, self.lb_db, self._args)
    # end load_drivers

    def audit_lb_pools(self):
        for pool_id, config_data, driver_data in self.lb_db.pool_list():
            if LoadbalancerPoolSM.get(pool_id):
                continue
            # Delete the pool from the driver
            driver = self._get_driver_for_provider(config_data['provider'])
            driver.delete_pool(config_data)
            self.lb_db.pool_remove(pool_id)

    def load_driver(self, sas):
        if sas.name in self._loadbalancer_driver:
            del(self._loadbalancer_driver[sas.name])
        if sas.driver:
            config = self._args.config_sections
            try:
                config.remove_section(sas.name)
            except Exception as ex:
                pass
            config.add_section(sas.name)
            for kvp in sas.kvpairs or []:
                config.set(sas.name, kvp['key'], kvp['value'])
            if sas.ha_mode:
                config.set(sas.name, 'ha_mode', sas.ha_mode)
            for sa in sas.service_appliances or []:
                saobj = ServiceApplianceSM.get(sa)
                config.set(sas.name, 'device_ip', saobj.ip_address)
                config.set(sas.name, 'user', saobj.user_credential['username'])
                config.set(sas.name, 'password',
                           saobj.user_credential['password'])
            self._loadbalancer_driver[sas.name] = \
                       importutils.import_object(sas.driver, sas.name,
                          self._svc_mon, self._vnc_lib, self.lb_db, self._args)
    # end load_driver

    def unload_driver(self, sas):
        if sas.name not in self._loadbalancer_driver:
            return
        del(self._loadbalancer_driver[sas.name])
    # end unload_driver

    def _get_driver_for_provider(self, provider_name):
        return self._loadbalancer_driver[provider_name]
    # end _get_driver_for_provider

    def _get_driver_for_pool(self, pool_id, provider=None):
        if not pool_id:
            return self.drivers[self._default_provider]
        if pool_id in self._pool_driver:
            return self._pool_driver[pool_id]
        if not provider:
            pool = LoadbalancerPoolSM.get(pool_id)
            provider = pool.provider
        driver = self._get_driver_for_provider(provider)
        self._pool_driver[pool_id] = driver
        return driver
    # end _get_driver_for_pool

    # Loadbalancer
    def loadbalancer_pool_add(self, pool):
        p = self.loadbalancer_pool_get_reqdict(pool)
        driver = self._get_driver_for_pool(p['id'], p['provider'])
        try:
            if not pool.last_sent:
                driver.create_pool(p)
            #elif p != pool.last_sent:
            else:
                driver.update_pool(pool.last_sent, p)
        except Exception as ex:
            pass
        self.lb_db.pool_config_insert(p['id'], p)
        return p
    # end loadbalancer_pool_add

    def loadbalancer_member_add(self, member):
        m = self.loadbalancer_member_get_reqdict(member)
        driver = self._get_driver_for_pool(m['pool_id'])
        try:
            if not member.last_sent:
                driver.create_member(m)
            elif m != member.last_sent:
                driver.update_member(member.last_sent, m)
        except Exception as ex:
            pass
        return m
    # end loadbalancer_member_add

    def virtual_ip_add(self, vip):
        v = self.virtual_ip_get_reqdict(vip)
        driver = self._get_driver_for_pool(v['pool_id'])
        try:
            if not vip.last_sent:
                driver.create_vip(v)
            elif v != vip.last_sent:
                driver.update_vip(vip.last_sent, v)
        except Exception as ex:
            pass
        return v
    # end  virtual_ip_add

    def delete_virtual_ip(self, obj):
        v = obj.last_sent
        driver = self._get_driver_for_pool(v['pool_id'])
        try:
            driver.delete_vip(v)
        except Exception as ex:
            pass
    # end delete_virtual_ip

    def delete_loadbalancer_member(self, obj):
        m = obj.last_sent
        driver = self._get_driver_for_pool(m['pool_id'])
        try:
            driver.delete_member(m)
        except Exception as ex:
            pass
    # end delete_loadbalancer_member

    def delete_loadbalancer_pool(self, obj):
        p = obj.last_sent
        driver = self._get_driver_for_pool(p['id'])
        try:
            driver.delete_pool(p)
        except Exception as ex:
            pass
        self.lb_db.pool_remove(p['id'])
    # end delete_loadbalancer_pool

    def update_hm(self, obj):
        hm = self.hm_get_reqdict(obj)
        current_pools = hm['pools'] or []
        old_pools = []
        if obj.last_sent:
            old_pools = hm['pools'] or []
 
        set_current_pools = set()
        set_old_pools = set()
        for i in current_pools:
            set_current_pools.add(i['pool_id'])
        for i in old_pools: 
            set_old_pools.add(i['pool_id'])
        update_pools = set_current_pools & set_old_pools
        delete_pools = set_old_pools - set_current_pools
        add_pools = set_current_pools - set_old_pools
        try:
            for pool in add_pools:
                driver = self._get_driver_for_pool(pool)
                driver.create_pool_health_monitor(hm, pool)
            for pool in delete_pools:
                driver = self._get_driver_for_pool(pool)
                driver.delete_pool_health_monitor(hm, pool)
            for pool in update_pools:
                driver = self._get_driver_for_pool(pool)
                driver.update_health_monitor(obj.last_sent, 
                                         hm, pool)
        except Exception as ex:
            pass
    # end update_hm

    def _get_vip_pool_id(self, vip):
        pool_refs = vip.loadbalancer_pool
        if pool_refs is None:
            return None
        return pool_refs
    # end _get_vip_pool_id

    def _get_interface_params(self, vip, props):
        port_id = vip.virtual_machine_interface
        if port_id is None:
            return None

        if not props['address']:
            vmi = VirtualMachineInterfaceSM.get(port_id)
            ip_refs = vmi.instance_ip
            if ip_refs:
                iip = InstanceIpSM.get(ip_refs)
                props['address'] = iip.address

        return port_id
    # end _get_interface_params

    def virtual_ip_get_reqdict(self, vip):
        props = vip.params
        port_id = self._get_interface_params(vip, props)

        res = {'id': vip.uuid,
               'tenant_id': vip.parent_uuid.replace('-', ''),
               'name': vip.display_name,
               'description': self._get_object_description(vip),
               'subnet_id': props['subnet_id'],
               'address': props['address'],
               'port_id': port_id,
               'protocol_port': props['protocol_port'],
               'protocol': props['protocol'],
               'pool_id': self._get_vip_pool_id(vip),
               'session_persistence': None,
               'connection_limit': props['connection_limit'],
               'admin_state_up': props['admin_state'],
               'status': self._get_object_status(vip)}

        if props['persistence_type']:
            sp = {'type': props['persistence_type']}
            if props['persistence_type'] == 'APP_COOKIE':
                sp['cookie_name'] = props['persistence_cookie_name']
            res['session_persistence'] = sp

        return res;
    # end virtual_ip_get_reqdict

    _loadbalancer_health_type_mapping = {
        'admin_state': 'admin_state_up',
        'monitor_type': 'type',
        'delay': 'delay',
        'timeout': 'timeout',
        'max_retries': 'max_retries',
        'http_method': 'http_method',
        'url_path': 'url_path',
        'expected_codes': 'expected_codes'
    }

    def hm_get_reqdict(self, health_monitor):
        res = {'id': health_monitor.uuid,
               'tenant_id': health_monitor.parent_uuid.replace('-', ''),
               'status': self._get_object_status(health_monitor)}

        props = health_monitor.params
        for key, mapping in self._loadbalancer_health_type_mapping.iteritems():
            value = props[key]
            if value is not None:
                res[mapping] = value

        pool_ids = []
        pool_back_refs = health_monitor.loadbalancer_pools
        for pool_back_ref in pool_back_refs or []:
            pool_id = {}
            pool_id['pool_id'] = pool_back_ref
            pool_ids.append(pool_id)
        res['pools'] = pool_ids

        return res
    # end hm_get_reqdict

    _loadbalancer_member_type_mapping = {
        'admin_state': 'admin_state_up',
        'status': 'status',
        'protocol_port': 'protocol_port',
        'weight': 'weight',
        'address': 'address',
    }

    def loadbalancer_member_get_reqdict(self, member):
        res = {'id': member.uuid,
               'pool_id': member.loadbalancer_pool,
               'status': self._get_object_status(member)}

        pool = LoadbalancerPoolSM.get(member.loadbalancer_pool)
        res['tenant_id'] = pool.parent_uuid.replace('-', '')

        props = member.params
        for key, mapping in self._loadbalancer_member_type_mapping.iteritems():
            value = props[key]
            if value is not None:
                res[mapping] = value

        return res
    # end loadbalancer_member_get_reqdict

    _loadbalancer_pool_type_mapping = {
        'admin_state': 'admin_state_up',
        'protocol': 'protocol',
        'loadbalancer_method': 'lb_method',
        'subnet_id': 'subnet_id'
    }

    def _get_object_description(self, obj):
        id_perms = obj.id_perms
        if id_perms is None:
            return None
        return id_perms['description']
    # end _get_object_description

    def _get_object_status(self, obj):
        id_perms = obj.id_perms
        if id_perms and id_perms['enable']:
            return "ACTIVE"
        return "PENDING_DELETE"
    # end _get_object_status

    def loadbalancer_pool_get_reqdict(self, pool):
        res = {
            'id': pool.uuid,
            'tenant_id': pool.parent_uuid.replace('-', ''),
            'name': pool.display_name,
            'description': self._get_object_description(pool),
            'status': self._get_object_status(pool),
        }

        props = pool.params
        for key, mapping in self._loadbalancer_pool_type_mapping.iteritems():
            value = props[key]
            if value is not None:
                res[mapping] = value

        # provider
        res['provider'] = pool.provider

        # vip_id
        res['vip_id'] = None
        vip_refs = pool.virtual_ip
        if vip_refs is not None:
            res['vip_id'] = vip_refs

        # members
        res['members'] = list(pool.members)

        # health_monitors
        res['health_monitors'] = list(pool.loadbalancer_healthmonitors)

        # TODO: health_monitor_status
        res['health_monitors_status'] = []
        return res