def _notify_agent(self, network_info):
     host = None
     cluster_id = network_info['cluster_id']
     if 'host' in network_info:
         host = network_info['host']
     else:
         agent = self._get_ovsvapp_agent_from_cluster(self.context,
                                                      cluster_id)
         LOG.debug("Agent chosen for notification: %s.", agent)
         if agent and 'host' in agent:
             host = agent['host']
         else:
             LOG.error(_LE("Failed to find OVSvApp Agent with host "
                           "%(host)s while releasing network allocations "
                           "for %(cluster)s in vCenter %(vcenter)s."),
                       {'host': host,
                        'vcenter': network_info['vcenter_id'],
                        'cluster': cluster_id})
             return
     try:
         LOG.info(_LI("Initiating device_delete RPC for network "
                      "%(network)s to OVSvApp agent on host %(host)s."),
                  {'host': host, 'network': network_info})
         self.notifier.device_delete(self.context, network_info, host,
                                     cluster_id)
     except Exception:
         LOG.exception(_LE("Failed to notify agent to delete port group."))

    def _parse_mapping(self, entry):
        """Parse an entry of cluster_dvs_mapping.

        :param entry: String value which is an entry in conf file
                      for cluster_dvs_mapping.
                      Could be a simple mapping in the form
                      clusterpath:dvsname or a comma separated one like
                      clusterpath1:dvsname1,clusterpath2:dvsname2
        :returns: A list of (cluster, dvs) tuples
        """
        try:
            cluster_dvs_list = []
            LOG.debug("Parsing cluster_dvs_mapping %s.", entry)
            mappings = entry.split(",")
            for mapping in mappings:
                cluster = None
                vds = None
                if ":" in mapping:
                    cluster, vds = mapping.split(":", 1)
                    cluster = cluster.strip()
                    vds = vds.strip()
                if not cluster or not vds:
                    LOG.error(_LE("Invalid value %s for opt "
                                  "cluster_dvs_mapping."), mapping)
                else:
                    cluster_dvs_list.append((cluster, vds))
        except Exception:
            LOG.exception(_LE("Invalid value %s for opt cluster_dvs_mapping."),
                          entry)
        return cluster_dvs_list

def is_valid_dvswitch(session, cluster_mor, dvs_name):
    """Validate a DVS.

    Check if DVS exists for a cluster specified in conf.
    Also validate if DVS is attached to all hosts in a cluster.
    """
    dvs_mor = get_dvs_mor_by_name(session, dvs_name)
    if dvs_mor:
        dvs_config = session._call_method(
            vim_util, "get_dynamic_property", dvs_mor,
            "DistributedVirtualSwitch", "config.host")
        # Get all the host attached to given VDS
        dvs_host_members = dvs_config[0]
        dvs_attached_host_ids = []
        for dvs_host_member in dvs_host_members:
            dvs_attached_host_ids.append(dvs_host_member.config.host.value)

        # Get all the hosts present in the cluster
        hosts_in_cluster = resource_util.get_host_mors_for_cluster(
            session, cluster_mor)

        # Check if the host on which OVSvApp VM is hosted is a part of DVSwitch
        if hosts_in_cluster:
            for host in hosts_in_cluster:
                hostname = resource_util.get_hostname_for_host_mor(
                    session, host)
                if hostname == cfg.CONF.VMWARE.esx_hostname:
                    if host.value not in dvs_attached_host_ids:
                        LOG.error(_LE("DVS not present on"
                                      "host %s"), host.value)
                        return False
            return hosts_in_cluster
    else:
        LOG.error(_LE("DVS not present %s"), dvs_name)
        return False

    def update_device_binding(self, rpc_context, **kwargs):
        agent_id = kwargs.get('agent_id')
        device_id = kwargs.get('device')
        host = kwargs.get('host')
        updated_ports = set()
        ports = None
        ports = self.plugin.get_ports(rpc_context,
                                      filters={'device_id': [device_id]})
        for port in ports:
            network = self.plugin.get_network(rpc_context, port['network_id'])
            port['network_type'] = network['provider:network_type']
            if network['provider:network_type'] == common_const.TYPE_VXLAN:
                retry_count = 3
                while retry_count > 0:
                    sleep = False
                    for pport in ports:
                        if pport['status'] != common_const.PORT_STATUS_ACTIVE:
                            sleep = True
                            break
                    if sleep:
                        time.sleep(retry_count * 3)
                        retry_count -= 1
                        ports = self.plugin.get_ports(rpc_context,
                                                      filters={'device_id':
                                                               [device_id]})
                    else:
                        port['status'] = common_const.PORT_STATUS_ACTIVE
                        break
                if retry_count == 0:
                    LOG.error(_LE("Failed to update binding for device %s, "
                                  "as the device has one of more ports "
                                  "in BUILD state."), device_id)
                    return

            port_id = port['id']
            LOG.debug("Port %(port_id)s update_port invoked by agent "
                      "%(agent_id)s for host %(host)s.",
                      {'port_id': port_id, 'agent_id': agent_id,
                       'host': host})
            new_port = {'port': {portbindings.HOST_ID: host}}
            try:
                updated_port = self.plugin.update_port(rpc_context, port_id,
                                                       new_port)
                updated_ports.add(updated_port['id'])
                if port['network_type'] == common_const.TYPE_VXLAN:
                    time.sleep(1)
                    new_status = (common_const.PORT_STATUS_BUILD
                                  if port['admin_state_up'] else
                                  common_const.PORT_STATUS_DOWN)
                    if port['status'] != new_status:
                        self.plugin.update_port_status(rpc_context, port['id'],
                                                       new_status, host)
                        time.sleep(1)
                        kwargs['device'] = port_id
                        self.update_device_up(rpc_context, **kwargs)
            except Exception:
                LOG.exception(_LE("Failed to update binding for port "
                                  "%s."), port_id)
        return updated_ports

 def initialize_driver(self):
     self.stop()
     self.driver = None
     self.vcenter_ip = cfg.CONF.VMWARE.vcenter_ip
     self.vcenter_username = cfg.CONF.VMWARE.vcenter_username
     self.vcenter_password = cfg.CONF.VMWARE.vcenter_password
     self.vcenter_api_retry_count = cfg.CONF.VMWARE.vcenter_api_retry_count
     self.wsdl_location = cfg.CONF.VMWARE.wsdl_location
     self.https_port = cfg.CONF.VMWARE.https_port
     self.ca_path = None
     self.connection_timeout = cfg.CONF.VMWARE.connection_timeout
     if cfg.CONF.VMWARE.cert_check:
         if not cfg.CONF.VMWARE.cert_path:
             LOG.error(_LE("SSL certificate path is not defined to "
                           "establish secure vCenter connection. "
                           "Aborting agent!"))
             raise SystemExit(1)
         elif not os.path.isfile(cfg.CONF.VMWARE.cert_path):
             LOG.error(_LE("SSL certificate does not exist at "
                           "the specified path %s. Aborting agent!"),
                       cfg.CONF.VMWARE.cert_path)
             raise SystemExit(1)
         else:
             self.ca_path = cfg.CONF.VMWARE.cert_path
     if (self.vcenter_ip and self.vcenter_username and
             self.vcenter_password and self.wsdl_location):
         vim_session.ConnectionHandler.set_vc_details(
             self.vcenter_ip,
             self.vcenter_username,
             self.vcenter_password,
             self.vcenter_api_retry_count,
             self.wsdl_location,
             self.ca_path,
             self.connection_timeout,
             self.https_port)
         vim_session.ConnectionHandler.start()
         if self.connection_thread:
             self.connection_thread.kill()
         self.connection_thread = eventlet.spawn(
             vim_session.ConnectionHandler.try_connection)
         try:
             self.connection_thread.wait()
         except greenlet.GreenletExit:
             LOG.warning(_LW("Thread waiting on vCenter connection "
                             "exited."))
             return
     else:
         LOG.error(_LE("Must specify vcenter_ip, vcenter_username, "
                       "vcenter_password and wsdl_location."))
         return
     self.driver = dvs_driver.DvsNetworkDriver()
     self.driver.set_callback(self.netcallback)
     for mapping in cfg.CONF.VMWARE.cluster_dvs_mapping:
         cluster_dvs_list = self._parse_mapping(mapping)
         for cluster, vds in cluster_dvs_list:
             self._add_cluster(cluster, vds)

 def try_connection(cls):
     while not cls.stopped:
         try:
             return cls.get_connection(create=True)
         except Exception as e:
             LOG.error(_LE("Connection to vCenter %(host_ip)s failed -"
                           "%(exception)s"), {"host_ip": cls.host_ip,
                                              "exception": e})
             LOG.error(_LE("Will retry after 60 secs"))
             time.sleep(60)
             LOG.error(_LE("Retrying VMWare Connection after 60 secs"))
             continue

 def monitor_events(self):
     try:
         LOG.info(_LI("Starting monitoring for vCenter updates"))
         version = ""
         self.state = constants.DRIVER_RUNNING
         while self.state in (constants.DRIVER_RUNNING):
             try:
                 LOG.debug("Waiting for vCenter updates...")
                 try:
                     updateSet = self.session._call_method(
                         vim_util,
                         "wait_for_updates_ex",
                         version)
                     if self.state != constants.DRIVER_RUNNING:
                         LOG.error(_LE("Driver is not in running state."))
                         break
                 except error_util.SocketTimeoutException:
                     # Ignore timeout.
                     LOG.warning(_LW("Ignoring socket timeouts while "
                                     "monitoring for vCenter updates."))
                     continue
                 if updateSet:
                     version = updateSet.version
                     events = self._process_update_set(updateSet)
                     LOG.debug("Sending events : %s.", events)
                     self.dispatch_events(events)
             except exceptions.VimFaultException as e:
                 # InvalidCollectorVersionFault happens
                 # on session re-connect.
                 # Re-initialize WaitForUpdatesEx.
                 if "InvalidCollectorVersion" in e.fault_list:
                     LOG.debug("InvalidCollectorVersion - "
                               "Re-initializing vCenter updates "
                               "monitoring.")
                     version = ""
                     for cluster_mor in self.clusters_by_id.values():
                         pfo = self._register_cluster_for_updates(
                             cluster_mor)
                         clu_id = cluster_mor.value
                         self.cluster_id_to_filter[clu_id] = pfo
                     continue
                 LOG.exception(_LE("VimFaultException while processing "
                                   "update set %s."), e)
             except Exception:
                 LOG.exception(_LE("Exception while processing update"
                                   " set."))
             time.sleep(0)
         LOG.info(_LI("Stopped monitoring for vCenter updates."))
     except Exception:
         LOG.exception(_LE("Monitoring for vCenter updates failed."))

 def _remove_all_flows(self, sec_br, port_id, del_provider_rules=False):
     """Remove all flows for a port."""
     LOG.debug("OVSF Removing flows start for port: %s.", port_id)
     try:
         sec_br.delete_flows(cookie="%s/-1" %
                             self.get_cookie(port_id))
         if del_provider_rules:
             sec_br.delete_flows(cookie="%s/-1" %
                                 self.get_cookie('pr' + port_id))
         port = self.filtered_ports.get(port_id)
         vlan = self._get_port_vlan(port_id)
         if 'mac_address' not in port or not vlan:
             LOG.debug("Invalid mac address or vlan for port "
                       "%s. Returning from _remove_all_flows.", port_id)
             return
         sec_br.delete_flows(table=ovsvapp_const.SG_LEARN_TABLE_ID,
                             dl_src=port['mac_address'],
                             vlan_tci="0x%04x/0x0fff" % vlan)
         sec_br.delete_flows(table=ovsvapp_const.SG_LEARN_TABLE_ID,
                             dl_dst=port['mac_address'],
                             vlan_tci="0x%04x/0x0fff" % vlan)
         sec_br.delete_flows(table=ovsvapp_const.SG_DEFAULT_TABLE_ID,
                             dl_src=port['mac_address'],
                             vlan_tci="0x%04x/0x0fff" % vlan)
         if del_provider_rules:
             sec_br.delete_flows(table=ovsvapp_const.SG_DEFAULT_TABLE_ID,
                                 dl_dst=port['mac_address'],
                                 vlan_tci="0x%04x/0x0fff" % vlan)
             sec_br.delete_flows(table=ovsvapp_const.SG_EGRESS_TABLE_ID,
                                 dl_src=port['mac_address'],
                                 vlan_tci="0x%04x/0x0fff" % vlan)
     except Exception:
         LOG.exception(_LE("Unable to remove flows %s."), port['id'])

 def delete_network_postcommit(self, context):
     network = context.current
     segments = context.network_segments
     vxlan_segments = []
     if segments:
         for segment in segments:
             if segment[api.NETWORK_TYPE] in self.supported_network_types:
                 vxlan_segments.append(segment)
     if not vxlan_segments:
         return
     try:
         stale_entries = ovsvapp_db.get_stale_local_vlans_for_network(
             network['id'])
         if stale_entries:
             for (vcenter, cluster, lvid) in stale_entries:
                 network_info = {'vcenter_id': vcenter,
                                 'cluster_id': cluster,
                                 'lvid': lvid,
                                 'network_id': network['id']}
                 if len(vxlan_segments) == 1:
                     seg_id = vxlan_segments[0][api.SEGMENTATION_ID]
                     net_type = vxlan_segments[0][api.NETWORK_TYPE]
                     network_info.update({'segmentation_id': seg_id,
                                          'network_type': net_type})
                 LOG.debug("Spawning thread for releasing network "
                           "VNI allocations for %s.", network_info)
                 self.threadpool.spawn_n(self._notify_agent, network_info)
                 LOG.info(_LI("Spawned a thread for releasing network "
                              "vni allocations for network: %s."),
                          network_info)
     except Exception:
         LOG.exception(_LE("Failed checking stale local vlan allocations."))

 def clean_port_filters(self, ports, remove_port=False):
     """Method to remove OVS rules for an existing VM port."""
     LOG.debug("OVSF Cleaning filters for  %s ports.", len(ports))
     if not ports:
         return
     with self.sg_br.deferred() as deferred_sec_br:
         for port_id in ports:
             try:
                 if not self.filtered_ports.get(port_id):
                     LOG.debug("Attempted to remove port filter "
                               "which is not in filtered %s.", port_id)
                     continue
                 if not remove_port:
                     self._remove_all_flows(deferred_sec_br, port_id)
                 else:
                     self._remove_all_flows(deferred_sec_br, port_id, True)
                     if self.provider_port_cache.__contains__(port_id):
                         self.provider_port_cache.remove(port_id)
                     else:
                         LOG.info(_LI("KeyError:Remove requested for "
                                      "port_id not present: %s"),
                                  self.provider_port_cache)
                     self.filtered_ports.pop(port_id, None)
             except Exception:
                 LOG.exception(_LE("Unable to delete flows for"
                                   " %s."), port_id)

    def update_port_filter(self, port):
        """Method to update OVS rules for an existing VM port."""
        LOG.debug("OVSF Updating port: %s filter.", port['id'])
        if port['id'] not in self.filtered_ports:
            LOG.warning(_LW("Attempted to update port filter which is not "
                            "filtered %s."), port['id'])
            return
        port_cookie = self.get_cookie(port['id'])
        port_provider_cookie = self.get_cookie('pr' + port['id'])
        try:
            with self.sg_br.deferred(full_ordered=True, order=(
                'del', 'mod', 'add')) as deferred_br:
                if port['id'] not in self.provider_port_cache:
                    self._remove_all_flows(deferred_br, port['id'], True)
                    self._add_flows(deferred_br, port,
                                    port_provider_cookie, True)
                    self.provider_port_cache.add(port['id'])
#                else:
#                    self._remove_all_flows(deferred_br, port['id'])
                self._setup_aap_flows(deferred_br, port)
                self._add_flows(deferred_br, port, port_cookie)
                if 'security_group_rules_deleted' in port:
                    self._remove_flows(deferred_br, port, port_cookie)

            self.filtered_ports[port['id']] = self._get_compact_port(port)
        except Exception:
            LOG.exception(_LE("Unable to update flows for %s."), port['id'])

 def update_ovsvapp_mitigated_cluster(self, context, id,
                                      ovsvapp_mitigated_cluster):
     _admin_check(context, 'UPDATE')
     res_dict = ovsvapp_mitigated_cluster['ovsvapp_mitigated_cluster']
     vcenter_id = res_dict['vcenter_id']
     cluster_id = res_dict['cluster_id']
     update_flags = dict()
     if 'being_mitigated' in res_dict:
         update_flags['being_mitigated'] = res_dict['being_mitigated']
     if 'threshold_reached' in res_dict:
         update_flags['threshold_reached'] = res_dict['threshold_reached']
     LOG.error(_LE("Updating the mitigation properties with "
                   "vCenter id %s."),
               vcenter_id)
     with context.session.begin(subtransactions=True):
         try:
             query = context.session.query(models.OVSvAppClusters)
             cluster_row = (query.filter(
                 models.OVSvAppClusters.vcenter_id == vcenter_id,
                 models.OVSvAppClusters.cluster_id == cluster_id
             ).with_lockmode('update').one())
             cluster_row.update(update_flags)
         except sa_exc.NoResultFound:
             _msg = ("No entry found for specified vCenter %(vcenter_id)s"
                     " cluster %(cluster_id)s") % {'vcenter_id': vcenter_id,
                                                   'cluster_id': cluster_id}
             raise exc.InvalidInput(error_message=_msg)
     return res_dict

    def remove_stale_port_flows(self, port_id, mac_address, vlan):
        """Remove all flows for a port."""

        LOG.debug("OVSF Removing flows for stale port: %s.", port_id)
        with self.sg_br.deferred() as deferred_sec_br:
            try:
                deferred_sec_br.delete_flows(cookie="%s/-1" %
                                             self.get_cookie(port_id))
                deferred_sec_br.delete_flows(cookie="%s/-1" %
                                             self.get_cookie('pr' + port_id))
                deferred_sec_br.delete_flows(
                    table=ovsvapp_const.SG_LEARN_TABLE_ID,
                    dl_src=mac_address,
                    dl_vlan=vlan)
                deferred_sec_br.delete_flows(
                    table=ovsvapp_const.SG_LEARN_TABLE_ID,
                    dl_dst=mac_address,
                    dl_vlan=vlan)
                deferred_sec_br.delete_flows(
                    table=ovsvapp_const.SG_LEARN_TABLE_ID,
                    dl_src=mac_address,
                    dl_vlan=vlan)
                deferred_sec_br.delete_flows(
                    table=ovsvapp_const.SG_LEARN_TABLE_ID,
                    dl_dst=mac_address,
                    dl_vlan=vlan)
                deferred_sec_br.delete_flows(
                    table=ovsvapp_const.SG_LEARN_TABLE_ID,
                    dl_src=mac_address,
                    dl_vlan=vlan)
            except Exception:
                LOG.exception(_LE("OVSF unable to remove flows for port: "
                                  "%s."), port_id)

def release_local_vlan(net_info):
    session = db_api.get_session()
    with session.begin(subtransactions=True):
        res_keys = ['vcenter_id', 'cluster_id', 'network_id']
        res = dict((k, net_info[k]) for k in res_keys)
        try:
            query = session.query(models.ClusterVNIAllocations)
            allocation = (query.filter(
                models.ClusterVNIAllocations.vcenter_id == res['vcenter_id'],
                models.ClusterVNIAllocations.cluster_id == res['cluster_id'],
                models.ClusterVNIAllocations.network_id == res['network_id']
            ).with_lockmode('update').one())
            if allocation.network_port_count == 0:
                allocation.update({'network_id': None,
                                   'allocated': False,
                                   'network_port_count': 0})
                LOG.info(_LI("Released lvid for network: %s."), res)
            else:
                LOG.info(_LI("Unable to release local vlan for network_id %s "
                             "because ports are available on network."),
                         res['network_id'])
        except sa_exc.NoResultFound:
            # Nothing to do, may be another controller cleared the record
            # We will just log and return.
            LOG.error(_LE("Network %(network)s is already de-allocated for "
                          "cluster %(cluster)s."),
                      {'network': net_info['network_id'],
                       'cluster': net_info['cluster_id']})

def create_network_map_from_config(config, pg_cache=False):
    """Creates physical network to dvs map from config"""
    connection = None
    while not connection:
        try:
            connection = api.VMwareAPISession(
                host=config.vsphere_hostname,
                port=config.host_port,
                server_username=config.vsphere_login,
                server_password=config.vsphere_password,
                api_retry_count=config.api_retry_count,
                task_poll_interval=config.task_poll_interval,
                scheme='https',
                create_session=True,
                cacert=config.ca_file,
                insecure=config.insecure,
                pool_size=config.connections_pool_size)
        except ConnectionError:
            LOG.error(_LE("No connection to vSphere. Retry in 10 sec..."))
            sleep(10)
    network_map = {}
    controller_class = DVSControllerWithCache if pg_cache else DVSController
    for pair in config.network_maps:
        network, dvs = pair.split(':')
        network_map[network] = controller_class(dvs, config.cluster_name,
                                                connection)
    return network_map

 def _setup_aap_flows(self, sec_br, port):
     """Method to help setup rules for allowed address pairs."""
     vlan = self._get_port_vlan(port['id'])
     if not vlan:
         LOG.error(_LE("Missing VLAN information for "
                       "port: %s."), port['id'])
         return
     if isinstance(port.get('allowed_address_pairs'), list):
         for addr_pair in port['allowed_address_pairs']:
             if netaddr.IPNetwork(addr_pair["ip_address"]).version == 4:
                 ap_proto = "ip"
             else:
                 ap_proto = "ipv6"
             sec_br.add_flow(priority=ovsvapp_const.SG_RULES_PRI,
                             table=ovsvapp_const.SG_DEFAULT_TABLE_ID,
                             cookie=self.get_cookie(port['id']),
                             dl_dst=port["mac_address"],
                             in_port=self.patch_ofport,
                             dl_src=addr_pair["mac_address"],
                             dl_vlan=vlan,
                             proto=ap_proto,
                             nw_src=addr_pair["ip_address"],
                             actions="resubmit(,%s),output:%s" %
                             (ovsvapp_const.SG_IP_TABLE_ID,
                              self.phy_ofport))

 def update_lvid_assignment(self, rpc_context, **kwargs):
     net_info = kwargs.get('net_info')
     if net_info:
         try:
             ovsvapp_db.release_local_vlan(net_info)
         except Exception:
             LOG.exception(_LE("Failed to release the local vlan"))
     return

 def _add_cluster(self, cluster, vds):
     try:
         self.driver.add_cluster(cluster, vds)
     except Exception:
         LOG.exception(_LE("Adding cluster %(cluster)s:%(vds)s failed."),
                       {'cluster': cluster, 'vds': vds})
     else:
         self.cluster_switch_mapping[cluster] = vds

 def add_cluster(self, cluster_path, switch_name):
     LOG.info(_LI("Adding cluster_switch_mapping %(path)s:%(switch)s."),
              {'path': cluster_path, 'switch': switch_name})
     if (cluster_path in cache.VCCache.get_cluster_switch_mapping() and
         cache.VCCache.get_switch_for_cluster_path(
             cluster_path) == switch_name):
         LOG.info(_LI("cluster_switch_mapping %(cp)s:%(sw)s already "
                      "present."),
                  {'cp': cluster_path, 'sw': switch_name})
         return
     valid, cluster_mor = self.validate_cluster_switch_mapping(cluster_path,
                                                               switch_name)
     if not valid:
         if cluster_path in cache.VCCache.get_cluster_switch_mapping():
             LOG.info(_LI("Removing invalid cluster_switch_mapping: "
                      "%(cp)s:%(sw)s."),
                      {'cp': cluster_path, 'sw': switch_name})
             self.remove_cluster(cluster_path, switch_name)
         return
     if cluster_path in cache.VCCache.get_cluster_switch_mapping():
         cluster_id = self._find_cluster_id_for_path(cluster_path)
         if cluster_id == cluster_mor.value:
             LOG.info(_LI("Updating switch name for cluster: "
                      "%(cp)s to %(sw)s."),
                      {'cp': cluster_path, 'sw': switch_name})
             cache.VCCache.add_switch_for_cluster_path(cluster_path,
                                                       switch_name)
             self.delete_stale_portgroups(switch_name)
             return
         else:
             # Now this path points to a different cluster.
             LOG.info(_LI("Removing cluster %(cid)s as now path %(cp)s "
                          "points to a different cluster."),
                      {'cid': cluster_id, 'cp': cluster_path})
             old_clu_mor = self.clusters_by_id[cluster_id]
             if cluster_id in self.cluster_id_to_filter:
                 self._unregister_cluster_for_updates(old_clu_mor)
                 del self.cluster_id_to_filter[cluster_id]
             cache.VCCache.remove_cluster_id(cluster_id)
             if cluster_id in self.clusters_by_id:
                 del self.clusters_by_id[cluster_id]
     LOG.info(_LI("Registering cluster for mapping %(cp)s:%(sw)s."),
              {'cp': cluster_path, 'sw': switch_name})
     property_filter_obj = self._register_cluster_for_updates(cluster_mor)
     # Cache the cluster.
     cache.VCCache.add_path_for_cluster_id(cluster_mor.value, cluster_path)
     self.clusters_by_id[cluster_mor.value] = cluster_mor
     self.cluster_id_to_filter[cluster_mor.value] = property_filter_obj
     cache.VCCache.add_switch_for_cluster_path(cluster_path,
                                               switch_name)
     try:
         self.delete_stale_portgroups(switch_name)
     except Exception:
         LOG.error(_LE("Exception wile deleting stale port groups: %s"),
                   switch_name)
     if self.state != constants.DRIVER_RUNNING and self.is_connected():
         self.state = constants.DRIVER_READY

def set_vm_poweroff(session, vm_mor):
    """Power off the VM."""

    try:
        task_ref = session._call_method(
            session._get_vim(), "PowerOffVM_Task", vm_mor)
        session.wait_for_task(task_ref)
    except Exception as e:
        LOG.exception(_LE("%s"), e)
        raise Exception(e)