Notifies that a peer space was disconnected.

@param peerURI
- the URI of the peer that was disconnected to.
@param space
- the identifier of the disconnected space.
358563
protected void firePeerDisconnected(URI peerURI, SpaceID space) {
        final NetworkServiceListener[] ilisteners;
        synchronized (this.listeners) {
            ilisteners = new NetworkServiceListener[this.listeners.size()];
            this.listeners.toArray(ilisteners);
        }
        for (final NetworkServiceListener listener : ilisteners) {
            listener.peerDisconnected(peerURI, space);
        }
    }
121895
def _disconnected(self, uri):
        """"""
        self.param_updater.close()
        self.is_updated = False
        # Clear all values from the previous Crazyflie
        self.toc = Toc()
        self.values = {}
1310650
public void removePeerFilterProvider(PeerFilterProvider provider) {
        lock.lock();
        try {
            checkNotNull(provider);
            checkArgument(peerFilterProviders.remove(provider));
        } finally {
            lock.unlock();
        }
    }
911970
private SocketChannel connect( URI transportURI ) throws PacketTransportException
    {
        String host = transportURI.getHost();
        int port = transportURI.getPort();
        
        try
        {
        	SocketChannel socketChannel = SocketChannel.open();
        	socketChannel.configureBlocking(false);
        	SocketUtils.setupSocket(socketChannel.socket(),
        			                socketSendBufferSize,
        			                socketRecvBufferSize);
        	        	
            log.debug("#"+id+" opening a TCP connection to "+host+":"+port);
            socketChannel.connect(new InetSocketAddress(host,port));
            
            return socketChannel;
        }
        catch (Exception e)
        {
            log.error("#"+id+" could not connect to "+host+":"+port,e);
            throw new PacketTransportException("Could not connect to "+host+":"+port+" : "+e.toString());
        }
    }
221916
public void setAuditRepositoryUri(URI uri)
    {
    	setAuditRepositoryHost(uri.getHost());
    	setAuditRepositoryPort(uri.getPort());
    	setAuditRepositoryTransport(uri.getScheme());
    }
912979
void topicSpaceCreated(DestinationHandler destination) throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "topicSpaceCreated", destination);

    // Synchronize around the topic space references to stop removal and
    // additions occuring at the same time. 
    synchronized (_topicSpaces)
    {
      // There are some proxies to register
      if (_topicSpaces.containsKey(destination.getUuid()))
      {
        final ArrayList topicSpacesCreated = new ArrayList();
        final ArrayList topicsCreated = new ArrayList();

        final TemporarySubscription tsubscription =
          (TemporarySubscription) _topicSpaces.get(destination.getUuid());

        // Get the list of all the subscriptions.
        final Iterator neighbourUuids = tsubscription.iMETopicList.keySet().iterator();

        // Iterate through the list of meNames to create PubSubOutputHandlers on.
        while (neighbourUuids.hasNext())
        {
          // Reset the created topicSpaces
          topicSpacesCreated.clear();

          // Reset the created topics
          topicsCreated.clear();

          // Get the next ME name.
          final SIBUuid8 neighbourUuid = (SIBUuid8) neighbourUuids.next();

          // Get the set of subscriptions that have been registered
          final Iterator subscriptions =
            ((List) tsubscription.iMETopicList.get(neighbourUuid)).iterator();

          Neighbour neighbour = getNeighbour(neighbourUuid);
          // Need a flag to indicate if this neighbour is
          // a recovered one or not.
          boolean recoveredNeighbour = (neighbour == null);
          
          // If the Neighbour wasn't found in the real list, check the recovered list as this may
          // contain it.
          if (neighbour == null)
          {
            synchronized(_recoveredNeighbours)
            {
              neighbour = (Neighbour)_recoveredNeighbours.get(neighbourUuid);
            }
          }

          // Iterate of the set of topics
          while (subscriptions.hasNext())
          {
            // Get the next topic.
            final MESubscription subscription = (MESubscription) subscriptions.next();

            // Create the proxy - this will get the create Destination
            // and attach a PubSubOutputHandler.
            final boolean proxyCreated =
              createProxy(neighbour, 
                          destination, 
                          subscription,
                          destination.getUuid(), 
                          subscription.getTopic(),
                          false);
                          
            try
            {
              // Add to MatchSpace, but only if it isn't a recovered neighbour.
              if (!recoveredNeighbour)
                subscription.eventPostCommitAdd(null);
            }
            catch (SevereMessageStoreException e)
            {
              // No FFDC code needed
              // Can never occur
            }

            // If the proxy is created, then we need to publish the event message
            // to any neighbours that are interested
            if (proxyCreated)
            {
              if (!recoveredNeighbour)
              {
                // Add the topicSpace and topic to the set of created topics.
                topicSpacesCreated.add(destination.getUuid());
                topicsCreated.add(subscription.getTopic());
              }
              else
              {
                // Add the OutputHandler to the list of known handlers.
                PubSubOutputHandler h = destination.getPubSubOutputHandler(neighbour.getUUID());
                neighbour.addPubSubOutputHandler(h);            
              }
            }
            else
            {
              // This is an error situation, as the destination now exists, 
              // so the proxy should have been created.
              final SIErrorException e =
                new SIErrorException(nls.getFormattedMessage(
                  "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                  new Object[] {
                    "com.ibm.ws.sib.processor.proxyhandler.Neighbours",
                    "1:463:1.113" },
                  null));
              
              FFDCFilter.processException(
                e,
                "com.ibm.ws.sib.processor.proxyhandler.Neighbours.topicSpaceCreated",
                "1:469:1.113",
                this);
                
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "topicSpaceCreated", e);  
              throw e;
            }
          }

          // Send the event message to the Neighbours interested
          // Get the Neighbour that represents this meName.
          _proxyHandler.subscribeEvent(
            topicSpacesCreated,
            topicsCreated,
            neighbour.getBusId(),
            null);
        }

        // Remove the Temporary subscriptions from the list.
        _topicSpaces.remove(destination.getUuid());
      }
      else
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          SibTr.debug(tc, "No proxy subscriptions to register");
      }

    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "topicSpaceCreated");
  }
338525
protected boolean pushNamespace(String prefix, String uri)
    {
        try
        {
            if (m_prefixMap.pushNamespace(
                prefix, uri, m_elemContext.m_currentElemDepth))
            {
                startPrefixMapping(prefix, uri);
                return true;
            }
        }
        catch (SAXException e)
        {
            // falls through
        }
        return false;
    }
54351
@Override
  public synchronized void remove(URI jobURI) {
    Preconditions.checkState(state() == State.RUNNING, String.format("%s is not running.", this.getClass().getName()));
    try {
      long startTime = System.currentTimeMillis();
      JobSpec jobSpec = getJobSpec(jobURI);
      Path jobSpecPath = getPathForURI(this.jobConfDirPath, jobURI);

      if (fs.exists(jobSpecPath)) {
        fs.delete(jobSpecPath, false);
        this.mutableMetrics.updateRemoveJobTime(startTime);
        this.listeners.onDeleteJob(jobURI, jobSpec.getVersion());
      } else {
        LOGGER.warn("No file with URI:" + jobSpecPath + " is found. Deletion failed.");
      }
    } catch (IOException e) {
      throw new RuntimeException("When removing a JobConf. file, issues unexpected happen:" + e.getMessage());
    } catch (SpecNotFoundException e) {
      LOGGER.warn("No file with URI:" + jobURI + " is found. Deletion failed.");
    }
  }
507527
public PeerEventingServiceDisconnected setPeerEventingServiceDisconnected(PeerEventingServiceDisconnected newPeerEventingServiceDisconnectedHandler) {
        PeerEventingServiceDisconnected ret = disconnectedHandler;
        disconnectedHandler = newPeerEventingServiceDisconnectedHandler;
        return ret;
    }
115380
private synchronized void registerNamespace(String prefix, String uri, boolean persist) throws NamespaceException, RepositoryException
   {
      if (namespaces.containsKey(prefix))
      {
         unregisterNamespace(prefix);
      }
      else if (prefixes.containsKey(uri))
      {
         unregisterNamespace(prefixes.get(uri));
      }
      if (persister != null && persist)
      {
         persister.addNamespace(prefix, uri);
      }
      final String newPrefix = new String(prefix);
      final String newUri = new String(uri);

      namespaces.put(newPrefix, newUri);
      prefixes.put(newUri, newPrefix);
   }
1139789
protected void fireSpaceDestroyed(Space space, boolean isLocalDestruction) {
		for (final SpaceRepositoryListener listener : this.listeners.getListeners(SpaceRepositoryListener.class)) {
			listener.spaceDestroyed(space, isLocalDestruction);
		}
	}
102080
public void setURI(URI uri) {
		if(SipServletMessageImpl.isSystemHeader(isModifiable)) {
			throw new IllegalStateException("this Address is used in a context where it cannot be modified");
		}
		this.getAddress().setURI(((URIImpl) uri).uri);
	}
714568
protected static boolean isAPIUri(Uri uri) {
        if (uri == null) {
            return false;
        }

        return getBaseUri().getHost().equals(uri.getHost());
    }
963083
public void removeConnections(String uri) {
        Objects.requireNonNull(uri, Required.URI.toString());

        this.cache.remove(Default.SSE_CACHE_PREFIX.toString() + uri);
    }
38921
def unregister_peer(self, connection_id):
        
        public_key = self.peer_to_public_key(connection_id)
        if public_key:
            self._consensus_notifier.notify_peer_disconnected(public_key)

        with self._lock:
            if connection_id in self._peers:
                del self._peers[connection_id]
                LOGGER.debug("Removed connection_id %s, "
                             "connected identities are now %s",
                             connection_id, self._peers)
                self._topology.set_connection_status(connection_id,
                                                     PeerStatus.TEMP)
            else:
                LOGGER.warning("Connection unregister failed as connection "
                               "was not registered: %s",
                               connection_id)
171145
def pre_disconnect(self, sid, namespace):
        
        if namespace not in self.pending_disconnect:
            self.pending_disconnect[namespace] = []
        self.pending_disconnect[namespace].append(sid)
1032983
public void connectRtcp(SocketAddress remoteAddress) {
		this.rtcpChannel.setRemotePeer(remoteAddress);
		
		if(logger.isDebugEnabled()) {
			logger.debug(this.mediaType + " RTCP channel " + this.ssrc + " has connected to remote peer " + remoteAddress.toString());
		}
	}