Removes a peer from BGP speaker.
967259
def remove_peer_from_bgp_speaker(self, speaker_id, body=None):
        """"""
        return self.put((self.bgp_speaker_path % speaker_id) +
                        "/remove_bgp_peer", body=body)
108442
def remove_from_tor(self, protocol):
        '''
        
        '''
        r = yield protocol.queue_command('DEL_ONION %s' % self.hostname[:-6])
        if r.strip() != 'OK':
            raise RuntimeError('Failed to remove hidden service: "%s".' % r)
141300
private void stopPublicationByProviderId(String providerParticipantId) {
        for (PublicationInformation publicationInformation : subscriptionId2PublicationInformation.values()) {
            if (publicationInformation.getProviderParticipantId().equals(providerParticipantId)) {
                removePublication(publicationInformation.getSubscriptionId());
            }
        }

        if (providerParticipantId != null && queuedSubscriptionRequests.containsKey(providerParticipantId)) {
            queuedSubscriptionRequests.removeAll(providerParticipantId);
        }
    }
558563
def update_bgp_speaker(self, bgp_speaker_id, body=None):
        """"""
        return self.put(self.bgp_speaker_path % bgp_speaker_id, body=body)
557914
def remove_child(self, router):
        ''''''
        if router in self.routes:
            self.routes.remove(router)
            router._parent = None
152680
def deallocate_ip(self, hostipaddress):
        
        delete_host_from_segment(hostipaddress, self.netaddr, self.auth, self.url)
231626
def remove_device(self, path):
        ""
        if self.__get_control_socket():
            self.sock.sendall("-%s\r\n\x00" % path)
            self.sock.recv(12)
            self.sock.close()
569676
def remove_recipient(recipient)
      raise 'Tried to remove recipient from a non-group channel' unless group?
      raise ArgumentError, 'Tried to remove a non-recipient from a group' unless recipient.is_a?(Recipient)

      @recipients.delete(recipient)
    end
3008
public void removePeer(Peer peer) throws InvalidArgumentException {
        if (shutdown) {
            throw new InvalidArgumentException(format("Can not remove peer from channel %s already shutdown.", name));
        }
        logger.debug(format("removePeer %s from channel %s", peer, toString()));

        checkPeer(peer);
        removePeerInternal(peer);
        peer.shutdown(true);

    }
326749
private void removeFromReplicaLayer(final Node followedReplica) {
		final Node prev = NeoUtils.getPrevSingleNode(followedReplica,
				SocialGraphRelationshipType.GRAPHITY);
		final Node next = NeoUtils.getNextSingleNode(followedReplica,
				SocialGraphRelationshipType.GRAPHITY);

		// bridge the user replica in the replica layer
		prev.getSingleRelationship(SocialGraphRelationshipType.GRAPHITY,
				Direction.OUTGOING).delete();
		if (next != null) {
			next.getSingleRelationship(SocialGraphRelationshipType.GRAPHITY,
					Direction.INCOMING).delete();
			prev.createRelationshipTo(next,
					SocialGraphRelationshipType.GRAPHITY);
		}

		// remove the followship
		followedReplica.getSingleRelationship(
				SocialGraphRelationshipType.FOLLOW, Direction.INCOMING)
				.delete();

		// remove the replica node itself
		followedReplica.getSingleRelationship(
				SocialGraphRelationshipType.REPLICA, Direction.OUTGOING)
				.delete();
		followedReplica.delete();
	}
1196537
def unjoin(self):
        
        self.debug("()")
        if self._joined.is_set():
            packet = APPUnjoinMessage(device_id=Id.NOT_SET)
            self._send_packet(self._server_ip, self._server_port, packet)
            self._joined.clear()
            self.info("Left the audience")
649987
public synchronized int removePTableOwner(ThinPhysicalTableOwner pTableOwner, boolean bFreeIfEmpty)
    {
        if (pTableOwner != null)
        {
            m_setPTableOwners.remove(pTableOwner);
            pTableOwner.setPTable(null);
        }
        if (m_setPTableOwners.size() == 0)
            if (bFreeIfEmpty)
        {
            this.free();
            return 0;
        }
        m_lTimeLastUsed = System.currentTimeMillis();
        return m_setPTableOwners.size();
    }
116874
def _remove(self, xer, primary):
        
        if xer in primary:
            notifier = primary.pop(xer)
            notifier.shutdown()
297172
def ws_disconnect(message):
    
    language = message.channel_session['knocker']
    gr = Group('knocker-{0}'.format(language))
    gr.discard(message.reply_channel)
436398
def list_route_advertised_from_bgp_speaker(self, speaker_id, **_params):
        """"""
        return self.get((self.bgp_speaker_path % speaker_id) +
                        "/get_advertised_routes", params=_params)
272466
def unregister(self, peer_id):
        
        with self.__lock:
            # Pop it from accesses (will raise a KeyError if absent)
            peer = self.peers.pop(peer_id)
            assert isinstance(peer, beans.Peer)

            # Remove it from groups
            for name in peer.groups:
                try:
                    # Clean up the group
                    group = self.groups[name]
                    group.remove(peer_id)

                    # Remove it if it's empty
                    if not group:
                        del self.groups[name]

                except KeyError:
                    # Be tolerant here
                    pass
473596
def unsubscribe(self, peer_jid):
        
        self.client.enqueue(
            stanza.Presence(type_=structs.PresenceType.UNSUBSCRIBE,
                            to=peer_jid)
        )