Deletes the configured OpenFlow controller address.

        This method is corresponding to the following ovs-vsctl command::

            $ ovs-vsctl del-controller <bridge>
358835
def del_controller(self):
        
        command = ovs_vsctl.VSCtlCommand('del-controller', [self.br_name])
        self.run_command([command])
1135923
def delete(self):
        
        if not self._ddoc_id:
            raise CloudantArgumentError(125)
        if not self._name:
            raise CloudantArgumentError(126)
        ddoc_id = self._ddoc_id
        if ddoc_id.startswith('_design/'):
            ddoc_id = ddoc_id[8:]
        url = '/'.join((self.index_url, ddoc_id, self._type, self._name))
        resp = self._r_session.delete(url)
        resp.raise_for_status()
380692
def deleteMember(self, address, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member/"+address
        return self.client.delete(uri, None, headers, query_params, content_type)
1076517
def unregister_switch_address(addr):
    
    ofp_handler = app_manager.lookup_service_brick(ofp_event.NAME)
    # Do nothing if ofp_handler is not started yet
    if ofp_handler.controller is None:
        return
    ofp_handler.controller.stop_client_loop(addr)
281179
def delete_router(self, context, router_id, router):
        """"""

        if router:
            router_name = self._arista_router_name(router_id, router['name'])
            mlag_peer_failed = False
            for s in self._servers:
                try:
                    self.delete_router_from_eos(router_name, s)
                    mlag_peer_failed = False
                except Exception:
                    if self._mlag_configured and not mlag_peer_failed:
                        # In paied switch, it is OK to fail on one switch
                        mlag_peer_failed = True
                    else:
                        msg = (_('Failed to create router %s on EOS') %
                               router_name)
                        LOG.exception(msg)
                        raise arista_exc.AristaServicePluginRpcError(msg=msg)
1023061
def delete_vlan(self, nexus_host, vlanid):
        """"""
        starttime = time.time()

        path_snip = snipp.PATH_VLAN % vlanid
        self.client.rest_delete(path_snip, nexus_host)

        self.capture_and_print_timeshot(
            starttime, "del_vlan",
            switch=nexus_host)
960267
def delete(self):
        """"""
        if lib.EnvDeleteRouter(self._env, self._name.encode()) == 0:
            raise RuntimeError("Unable to delete router %s" % self._name)
465696
def delete(options = {})
      options = options.merge(endpoint_arn: @arn)
      resp = @client.delete_endpoint(options)
      resp.data
    end
291592
def Delete(self,location=None):
		

		if not location:  location = clc.v2.Account.GetLocation(session=self.session)

		return clc.v2.API.Call('POST','/v2-experimental/networks/%s/%s/%s/release' % (self.alias, location, self.id),
		                       session=self.session)
1215077
def remove_nio(self, nio):
        
        if self._hypervisor:
            yield from self._hypervisor.send('nio_bridge remove_nio "{name}" {nio}'.format(name=self._name, nio=nio))
        self._nios.remove(nio)
142137
def delete(self, svc_rec=None, ipaddr=None, proto=None, port=None):
        
        return self.send.service_del(svc_rec, ipaddr, proto, port)
328562
def delete(self):
        
        self.requester.delete(
            '/{endpoint}/{id}', endpoint=self.endpoint,
            id=self.id
        )
        return self
344610
def adapter_remove_nio_binding(self, adapter_number):
        

        try:
            adapter = self._ethernet_adapters[adapter_number]
        except KeyError:
            raise VirtualBoxError("Adapter {adapter_number} doesn't exist on VirtualBox VM '{name}'".format(name=self.name,
                                                                                                            adapter_number=adapter_number))

        if self.is_running():
            yield from self._ubridge_send("bridge delete {name}".format(name="VBOX-{}-{}".format(self._id, adapter_number)))
        vm_state = yield from self._get_vm_state()
        if vm_state == "running":
            yield from self._control_vm("setlinkstate{} off".format(adapter_number + 1))

        nio = adapter.get_nio(0)
        if isinstance(nio, NIOUDP):
            self.manager.port_manager.release_udp_port(nio.lport, self._project)
        adapter.remove_nio(0)

        log.info("VirtualBox VM '{name}' [{id}]: {nio} removed from adapter {adapter_number}".format(name=self.name,
                                                                                                     id=self.id,
                                                                                                     nio=nio,
                                                                                                     adapter_number=adapter_number))
        return nio
20356
def _delete_ubridge_connection(self, adapter_number):
        

        vnet = "ethernet{}.vnet".format(adapter_number)
        if vnet not in self._vmx_pairs:
            raise VMwareError("vnet {} not in VMX file".format(vnet))
        yield from self._ubridge_send("bridge delete {name}".format(name=vnet))
1170495
def remove_usb_controller(self, name):
        
        if not isinstance(name, basestring):
            raise TypeError("name can only be an instance of type basestring")
        self._call("removeUSBController",
                     in_p=[name])
1162566
def vswitch_delete(self, vswitch_name, persist=True):
        
        self._networkops.delete_vswitch(vswitch_name, persist)
1128957
def delete(self, virtual_host):
        
        virtual_host = quote(virtual_host, '')
        return self.http_client.delete(API_VIRTUAL_HOST % virtual_host)