Removes the peer connection from the channel.
This does NOT unjoin the peer from from the channel.
Fabric does not support that at this time -- maybe some day, but not today

@param peer
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);

    }
810661
func (s *server) removePeer(p *peer) {
	if p == nil {
		return
	}

	srvrLog.Debugf("removing peer %v", p)

	// As the peer is now finished, ensure that the TCP connection is
	// closed and all of its related goroutines have exited.
	p.Disconnect(fmt.Errorf("server: disconnecting peer %v", p))

	// If this peer had an active persistent connection request, remove it.
	if p.connReq != nil {
		s.connMgr.Remove(p.connReq.ID())
	}

	// Ignore deleting peers if we're shutting down.
	if s.Stopped() {
		return
	}

	pubStr := string(p.addr.IdentityKey.SerializeCompressed())

	delete(s.peersByPub, pubStr)

	if p.inbound {
		delete(s.inboundPeers, pubStr)
	} else {
		delete(s.outboundPeers, pubStr)
	}
}
616339
public boolean removeConnectedEventListener(PeerConnectedEventListener listener) {
        boolean result = ListenerRegistration.removeFromList(listener, peerConnectedEventListeners);
        for (Peer peer : getConnectedPeers())
            peer.removeConnectedEventListener(listener);
        for (Peer peer : getPendingPeers())
            peer.removeConnectedEventListener(listener);
        return result;
    }
934280
@ObjectiveCName("onConversationClosedWithPeer:")
    public void onConversationClosed(@NotNull Peer peer) {
        modules.getEvents().post(new PeerChatClosed(peer));
    }
824014
private void disconnect() {
        localStream = null;
        localRender = null;
        remoteRender = null;

        if (peerConnection != null) {
            peerConnection.dispose();
            peerConnection = null;
        }

        if (videoSource != null) {
            videoSource.dispose();
            videoSource = null;
        }

        if (null != directConnection) {
            directConnection.setListener(null);
            directConnection = null;
        }

        if (null != signalingChannel) {
            RespokeSignalingChannel.Listener signalingChannelListener = signalingChannel.GetListener();
            if (null != signalingChannelListener) {
                signalingChannelListener.callTerminated(this);
            }
        }

        listenerReference = null;
        endpoint = null;
        toEndpointId = null;
        toType = null;
        signalingChannel = null;
    }
392582
@Override
  public void _Network_Peers_removePeer(String name) throws MBeanException {
    try {
      MutablePeerTable n = (MutablePeerTable) stack.unwrap(PeerTable.class);
      n.removePeer(name);
    }
    catch (InternalException e) {
      throw new MBeanException(e, "Failed to remove peer with name '" + name + "'");
    }
  }
746663
protected void resolveAndDispatch (final ChatChannel channel)
    {
        NodeObject.Lock lock = new NodeObject.Lock("ChatChannel", channel.getLockName());
        _peerMan.performWithLock(lock, new PeerManager.LockedOperation() {
            public void run () {
                ((CrowdNodeObject)_peerMan.getNodeObject()).addToHostedChannels(channel);
                finishResolveAndDispatch(channel);
            }
            public void fail (String peerName) {
                final List<UserMessage> msgs = _resolving.remove(channel);
                if (peerName == null) {
                    log.warning("Failed to resolve chat channel due to lock failure",
                                "channel", channel);
                } else {
                    // some other peer resolved this channel first, so forward any queued messages
                    // directly to that node
                    _peerMan.invokeNodeAction(peerName, new ChannelAction(channel) {
                        @Override protected void execute () {
                            for (final UserMessage msg : msgs) {
                                _channelMan.dispatchSpeak(_channel, msg);
                            }
                        }
                    });
                }
            }
        });
    }
169514
@Skip
    @Override
    public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise)
            throws Exception {
        ctx.disconnect(promise);
    }
33339
function removeConnection(conn) {

  this.emit('disconnect');

  conn.removeAllListeners('input');
  conn.removeAllListeners('output');

  // clean channel subscriptions
  if(conn.client.pubsub) {
    // must slice channels ref
    this._pubsub.unsubscribe(
      conn, conn.client.pubsub.channels.slice(0));
  }

  // clean pattern subscriptions
  // client.pubsub can be null after
  // removing channel subscriptions
  if(conn.client.pubsub) {
    // must slice patterns ref
    this._pubsub.punsubscribe(
      conn, conn.client.pubsub.patterns.slice(0));
  }

  var ind = this._conn.indexOf(conn);
  // remove the connection reference
  // the server disconnect listener is once
  // so we should always have a valid
  // index into the array
  this._conn.splice(ind, 1);
}
625193
public void peerConnectionDidOpenDataChannel(DataChannel newDataChannel) {
        if (null != dataChannel) {
            // Replacing the previous connection, so disable observer messages from the old instance
            dataChannel.unregisterObserver();
        } else {
            new Handler(Looper.getMainLooper()).post(new Runnable() {
                public void run() {
                    if (null != listenerReference) {
                        Listener listener = listenerReference.get();
                        if (null != listener) {
                            listener.onStart(RespokeDirectConnection.this);
                        }
                    }
                }
            });
        }

        dataChannel = newDataChannel;
        newDataChannel.registerObserver(this);
    }
730901
public void removeSession(Session session) {
		InetSocketAddress remoteSocketAddress = session
				.getRemoteSocketAddress();
		log.warn("Remove a session: "
				+ SystemUtils.getRawAddress(remoteSocketAddress) + ":"
				+ remoteSocketAddress.getPort());
		this.sessionList.remove(session);
	}
1008885
public static synchronized void removeEndpoint(InetAddress ep)
    {
        String req = "DELETE FROM system.%s WHERE peer = ?";
        executeInternal(String.format(req, PEERS_CF), ep);
    }
701724
function(connection) {
      var t = this;
      log.info('removeConnection', 'Conn_' + connection.id);
      connection.disconnect('connection_removed');
      t.connections.remove(connection);
      t.trigger('connection:remove', connection);
    }
447739
public void removeConnectionListener(KNXListener l)
	{
		synchronized (listeners) {
			if (listeners.remove(l))
				listenersCopy = new ArrayList(listeners);
		}
	}
788430
private void cleanup_heartbeat_proxies() {
        // disconnect the pushsupplier to stop receiving events
        Enumeration keys = event_callback_map.keys();
        while (keys.hasMoreElements()) {
            String name = (String) keys.nextElement();
            EventCallBackStruct callback_struct = event_callback_map.get(name);
            try {
                EventChannelStruct ec_struct = channel_map.get(callback_struct.channel_name);
                if (ec_struct.structuredProxyPushSupplier != null) {
                    //System.out.println("Disconnect " + callback_struct.channel_name);
                    ec_struct.structuredProxyPushSupplier.disconnect_structured_push_supplier();
                    ec_struct.structuredProxyPushSupplier = null;
                }
            } catch (Exception e) {
                System.out.println(e);
            }
            event_callback_map.remove(name);
        }
    }
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")
378181
public void removeConnection(WebSocketConnection conn) {
        if (conn != null) {
            WebSocketScope scope = getScope(conn);
            if (scope != null) {
                scope.removeConnection(conn);
                if (!scope.isValid()) {
                    // scope is not valid. delete this.
                    removeWebSocketScope(scope);
                }
            }
        }
    }