Remove a router from hosting_device.
194148
def remove_router_from_hosting_device(self, client, hosting_device_id,
                                          router_id):
        """"""
        res_path = hostingdevice.HostingDevice.resource_path
        return client.delete((res_path + DEVICE_L3_ROUTERS + "/%s") % (
            hosting_device_id, router_id))
532019
def delete_router_from_eos(self, router_name, server):
        
        cmds = []
        for c in self.routerDict['delete']:
            cmds.append(c.format(router_name))
        if self._mlag_configured:
            for c in self._additionalRouterCmdsDict['delete']:
                cmds.append(c)

        self._run_config_cmds(cmds, server)
250475
def remove_port_profile_to_delete(self, profile_name, device_id):
        """"""
        with self.session.begin(subtransactions=True):
            self.session.query(ucsm_model.PortProfileDelete).filter_by(
                profile_id=profile_name, device_id=device_id).delete()
163452
def delete_hosting_device_resources(self, context, tenant_id, mgmt_port,
                                        **kwargs):
        """"""

        if mgmt_port is not None:
            try:
                self._cleanup_hosting_port(context, mgmt_port['id'])
            except n_exc.NeutronException as e:
                LOG.error("Unable to delete port:%(port)s after %(tries)d"
                          " attempts due to exception %(exception)s. "
                          "Skipping it", {'port': mgmt_port['id'],
                                          'tries': DELETION_ATTEMPTS,
                                          'exception': str(e)})
479999
def add_router_to_hosting_device(self, client, hosting_device_id, body):
        """"""
        res_path = hostingdevice.HostingDevice.resource_path
        return client.post((res_path + DEVICE_L3_ROUTERS) %
                           hosting_device_id, body=body)
960267
def delete(self):
        """"""
        if lib.EnvDeleteRouter(self._env, self._name.encode()) == 0:
            raise RuntimeError("Unable to delete router %s" % self._name)
341491
def _process_removed_port(self, device):
        """"""
        LOG.debug("Trying to remove the port %r", device)
        self._update_port_status_cache(device, device_bound=False)
        self._port_unbound(device, vnic_deleted=True)

        LOG.debug("The port was successfully removed.")
        self._removed_ports.discard(device)
482913
def deactivate(self):
        """"""
        if lib.EnvDeactivateRouter(self._env, self._name.encode()) == 0:
            raise RuntimeError("Unable to deactivate router %s" % self._name)
165532
def remove_ipv4addr(self, ipv4addr):
        
        for addr in self.ipv4addrs:
            if ((isinstance(addr, dict) and addr['ipv4addr'] == ipv4addr) or
                (isinstance(addr, HostIPv4) and addr.ipv4addr == ipv4addr)):
                self.ipv4addrs.remove(addr)
                break
1154781
def clear_dns_cache(self,
                        host: Optional[str]=None,
                        port: Optional[int]=None) -> None:
        """"""
        if host is not None and port is not None:
            self._cached_hosts.remove((host, port))
        elif host is not None or port is not None:
            raise ValueError("either both host and port "
                             "or none of them are allowed")
        else:
            self._cached_hosts.clear()
407611
def remove_writer(self, address):
        
        log_debug("[#0000]  C: <ROUTING> Removing writer %r", address)
        self.routing_table.writers.discard(address)
        log_debug("[#0000]  C: <ROUTING> table=%r", self.routing_table)
626622
def remove_host_mapping(interface, nexus_ip):
    """"""

    LOG.debug("remove_host_mapping() called")
    session = bc.get_writer_session()
    try:
        mapping = _lookup_one_host_mapping(
                      session=session,
                      if_id=interface,
                      switch_ip=nexus_ip)
        session.delete(mapping)
        session.flush()
    except c_exc.NexusHostMappingNotFound:
        pass
367854
def uninstall_host(trg_queue, *hosts, **kwargs):
    ''''''
    # immediately down the queue
    item_user = kwargs.pop('item_user', None)
    item_group = kwargs.pop('item_group', None)
    item_mode = kwargs.pop('item_mode', None)
    for host in hosts:
    # immediately down the queue
        try:
            down_host(trg_queue, host, user=item_user, group=item_group,
                 mode=(_c.FSQ_ITEM_MODE if item_mode is None else item_mode))
        except FSQError, e:
            raise FSQInstallError(e.errno, wrap_io_os_err(e))
        tmp_full, tmp_queue = _tmp_trg(host, fsq_path.hosts(trg_queue))
        _remove_dir(fsq_path.base(trg_queue, host), tmp_full, trg_queue)
380671
def remove(self, transport):
        
        if transport.uid in self.transports:
            del (self.transports[transport.uid])
788596
def remove(self, connection):
        ''''''
        key = (connection.host, connection.port)
        with self._lock:
            found = self._connections.pop(key, None)
        try:
            self.close_connection(found)
        except Exception as exc:
            logger.warn('Failed to close %s: %s', connection, exc)
        return found
804914
def destroy(self):
        """"""
        r = api.Resources(self.provider_conf.to_dict())
        # insert force_deploy
        r.destroy()
1080557
def delete_router_references(self, snet, address=None, dnets=None):
        """"""
        if _debug: NetworkServiceAccessPoint._debug("delete_router_references %r %r %r", snet, address, dnets)

        # see if we have an adapter for the snet
        if snet not in self.adapters:
            raise RuntimeError("no adapter for network: %d" % (snet,))

        # pass this along to the cache
        self.router_info_cache.delete_router_info(snet, address, dnets)