Java ConnectException類代碼示例

import java.rmi.ConnectException; //導入依賴的package包/類
public static ExternalServiceException getExternalServiceException(Exception e) {
    if (e instanceof ExternalServiceException) {
        return (ExternalServiceException) e;
    } else if (e instanceof RemoteException) {
        if (isLocalProblem((RemoteException) e)) {
            return new ExternalServiceException("Communication with the server could not be started.", e);
        }
        return new ExternalServiceException("An error occurred on the external server side.", e);
    } else if (e instanceof RuntimeException) {
        return new ExternalServiceException("An unexpected error occurred in the server. [" + e.getMessage() + "]", e);
    } else if (e instanceof HttpException) {
        return new ExternalServiceException("Unexpected error occurred in HTTP communication with external server. [" + e.getMessage() + "]", e);
    } else if (e instanceof ConnectException) {
        return new ExternalServiceException("Could not connect to external server. [" + e.getMessage() + "]", e);
    } else if (e instanceof IOException) {
        return new ExternalServiceException("An unexpected error occurred in the I / O with the external server. [" + e.getMessage() + "]", e);
    }
    return new ExternalServiceException("An unexpected error occurred. Response=[" + e.getMessage() + "]", e);
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
public static void agentmain(String args, Instrumentation instrumentation) throws RemoteException {
    String name = null;
    for (String arg : args.split(",")) {
        if (arg.startsWith("name=")) {
            name = arg.replace("name=", "");
        }
    }
    if (name == null) {
        throw new IllegalArgumentException("The name to use for the rmi server was not provided as an argument to the java agent.");
    }
    Registry registry = LocateRegistry.getRegistry();
    if (registry != null) {
        DefaultServerImpl rmi = new DefaultServerImpl(ClassLoader.getSystemClassLoader());
        try {
            //Attempt to bind to the registry stub that was returned.
            registry.rebind(name, rmi);
        } catch (ConnectException ce) {
            //Couldn't bind to it (perhaps it doesn't exist), creating a new one.
            registry = LocateRegistry.createRegistry(Registry.REGISTRY_PORT);
            registry.rebind(name, rmi);
        }
    }
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
/**
 * @deprecated
 */
public RemoteCall newCall(RemoteObject obj, Operation[] op, int opnum,
                          long hash) throws RemoteException
{
  UnicastConnection conn;

  try
    {
      conn = manager.getConnection();
    }
  catch (IOException e1)
    {
      throw new ConnectException("connection failed to host: "
                                 + manager.serverName, e1);
    }

  // obj: useless?

  return (new UnicastRemoteCall(conn, objid, opnum, hash));
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
@Override
protected RemoteSingleRun getRealRun(UsernamePrincipal creator,
		Workflow workflow, UUID id) throws Exception {
	@Nonnull
	byte[] wf = serializeWorkflow(workflow);
	for (int i = 0; i < 3; i++) {
		initFactory();
		try {
			return getRealRun(creator, wf, id);
		} catch (ConnectException | ConnectIOException e) {
			// factory was lost; try to recreate
		}
		killFactory();
	}
	throw new NoCreateException("total failure to connect to factory "
			+ factoryProcessName + "despite attempting restart");
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
@Override
protected RemoteSingleRun getRealRun(UsernamePrincipal creator,
		Workflow workflow, UUID id) throws Exception {
	byte[] wf = serializeWorkflow(workflow);
	String username = mapper == null ? null : mapper
			.getUsernameForPrincipal(creator);
	if (username == null)
		throw new Exception("cannot determine who to run workflow as; "
				+ "local identity mapper returned null");
	for (int i = 0; i < 3; i++) {
		if (!factory.containsKey(username))
			initFactory(username);
		try {
			return getRealRun(creator, username, wf, id);
		} catch (ConnectException | ConnectIOException e) {
			// factory was lost; try to recreate
		}
		factory.remove(username);
	}
	throw new NoCreateException("total failure to connect to factory "
			+ factoryProcessName + "despite attempting restart");
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
@Override
public void run() {

	final String name = root.getAbsolutePath();
	InetAddress current = null;
	try {
		current = InetAddress.getLocalHost();
	} catch (final UnknownHostException e1) {
		e1.printStackTrace();
		return;
	}
	try {
		try {
			// first try to call existing service
			invoke(current, name);

		} catch (final ConnectException e) {
			startInvoker(name);
			invoke(current, name);
		}
	} catch (final Throwable t) {
		t.printStackTrace();
	}
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
public void run()
{
	try{
		//System.out.println("heartbeat");
		String[] putarr = new String[putList.size()];
		putList.toArray(putarr);
		pk.heartbeat(putarr, sessionid);
	}catch(Exception e){
		//e.printStackTrace();
		LogUtil.info("[PutHbTask]", "[heartbeat:]", e.getMessage());
		//this.cancel();
		//HbDaemo.tm.cancel();
		if(e instanceof ConnectException){
			this.pk = pl.getNextLeader();
		}
	}
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
static final AbstractClientConnection getClientConnection(Endpoint ep)
        throws IOException, UnknownHostException, ConnectException,
        ConnectIOException {
    Socket sock = null;
    AbstractClientConnection ret;
    
    RMIClientSocketFactory csf = (ep.getCsf() != null) ? ep.getCsf()
            : RMISocketFactory.getSocketFactory();
    if (csf == null) {
        csf = RMISocketFactory.getDefaultSocketFactory();
    }
    sock = csf.createSocket(ep.getEndpointID().getHost(), ep.getPort());
    if (SO_TIME_OUT != 0) {
        sock.setSoTimeout(SO_TIME_OUT);
    }
    sock.setTcpNoDelay(true);
    if (sock instanceof HttpSocketClientSide) {
        ret = new SingleOpClientConnection(sock, ep);
    } else {
        ret = new StreamClientConnection(sock, ep);
    }
    return ret;
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
public static boolean isLocalProblem(RemoteException e) {
    if (e instanceof ConnectIOException) {
        return true;
    } else if (e instanceof ConnectException) {
        return true;
    } else if (e instanceof UnknownHostException) {
        return true;
    }
    return false;
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
private void doTestInvokesMethodOnEjbInstanceWithConnectExceptionWithRefresh(
		boolean lookupHomeOnStartup, boolean cacheHome) throws Exception {

	final RemoteInterface ejb = mock(RemoteInterface.class);
	given(ejb.targetMethod()).willThrow(new ConnectException(""));

	int lookupCount = 2;
	if (!cacheHome) {
		lookupCount++;
		if (lookupHomeOnStartup) {
			lookupCount++;
		}
	}

	final String jndiName= "foobar";
	Context mockContext = mockContext(jndiName, ejb);

	SimpleRemoteSlsbInvokerInterceptor si = configuredInterceptor(mockContext, jndiName);
	si.setRefreshHomeOnConnectFailure(true);
	si.setLookupHomeOnStartup(lookupHomeOnStartup);
	si.setCacheHome(cacheHome);

	RemoteInterface target = (RemoteInterface) configuredProxy(si, RemoteInterface.class);
	try {
		target.targetMethod();
		fail("Should have thrown RemoteException");
	}
	catch (ConnectException ex) {
		// expected
	}

	verify(mockContext, times(lookupCount)).close();
	verify(ejb, times(2)).remove();
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
@Test
public void declaresException() throws Exception {
	Method remoteExMethod = A.class.getDeclaredMethod("foo", Integer.class);
	assertTrue(ReflectionUtils.declaresException(remoteExMethod, RemoteException.class));
	assertTrue(ReflectionUtils.declaresException(remoteExMethod, ConnectException.class));
	assertFalse(ReflectionUtils.declaresException(remoteExMethod, NoSuchMethodException.class));
	assertFalse(ReflectionUtils.declaresException(remoteExMethod, Exception.class));

	Method illegalExMethod = B.class.getDeclaredMethod("bar", String.class);
	assertTrue(ReflectionUtils.declaresException(illegalExMethod, IllegalArgumentException.class));
	assertTrue(ReflectionUtils.declaresException(illegalExMethod, NumberFormatException.class));
	assertFalse(ReflectionUtils.declaresException(illegalExMethod, IllegalStateException.class));
	assertFalse(ReflectionUtils.declaresException(illegalExMethod, Exception.class));
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
private Observable<HttpResponseChunk> emitChunksWithError(final int statusCode, final int restarts,
        final int events) {
    final AtomicInteger restartCounter = new AtomicInteger(0);
    return Observable.defer(() -> {
            final int restart = restartCounter.incrementAndGet();
            final Observable<HttpResponseChunk> chunks = emitRange(statusCode, restarts, events, restart);
            final Throwable t = restart % 2 == 0 ? new SocketTimeoutException("Test Socket timeout")
                                                 : new ConnectException("Test Connection failed");
            return Observable.concat(chunks, Observable.error(t));
        });
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
public static boolean isConnectOrCloseException(Throwable e) {
    if (e instanceof ConnectException && 
        e.getCause() != null && 
        e.getCause() instanceof IOException) {
        
        if (e.getCause() instanceof ClosedChannelException || e.getCause() instanceof java.net.ConnectException) {
            return true;
        }

        if (e.getCause().getMessage() != null && e.getCause().getMessage().contains("aborted")) {
            return true;
        }

        if (e.getCause().getMessage() != null && e.getCause().getMessage().contains("Connection reset by peer")) {
            return true;
        }
    }
    if(e instanceof LRMINoSuchObjectException) {
        return true;
    }
    if (e instanceof IOException) {
        if (e.getMessage() != null && e.getMessage().startsWith("Connection reset by peer")) {
            return true;
        }
    }
    return false;
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
/**
 * 創建建立 RMI 客戶端 並連接
 *
 * @throws RemoteException
 *             遠程異常
 * @throws NotBoundException
 *             未綁定異常
 */
private boolean createRMIClient() {

	// ready address and port
	String address = getServerConfig().getMasterAddress();
	int port = getServerConfig().getMasterPort();

	// try to connect
	try {
		logger.info("正在創建 RMI 客戶端....");

		Registry masterRegistry = LocateRegistry.getRegistry(address, port,
				new SslRMIClientSocketFactory());

		_masterServer = (MasterRMIServerInterface) masterRegistry
				.lookup("MasterServer");
		_masterServer.ping();
		boolean success = _masterServer.registerServer(getServerConfig()
				.getServerKey(), _masterClientObj);
		if (!success) {
			logger.error("注冊服務失敗！...");
		} else {
			logger.info("已經成功注冊上管理服務...");
			return true;
		}
	} catch (ConnectException connectException) {
		logger.error(" 嘗試連接到     MasterServer  連接失敗  :: ({}:{})[{}]", address,
				port, connectException.getMessage());
	} catch (RemoteException | NotBoundException ex) {
		logger.error("注冊服務失敗：", ex);
	}
	return false;
}
 

import java.rmi.ConnectException; //導入依賴的package包/類
private RemoteRunFactory getRemoteFactoryHandle(String name)
		throws RemoteException, NotBoundException {
	log.info("about to look up resource called " + name);
	try {
		// Validate registry connection first
		getTheRegistry().list();
	} catch (ConnectException | ConnectIOException e) {
		log.warn("connection problems with registry", e);
	}
	RemoteRunFactory rrf = (RemoteRunFactory) getTheRegistry().lookup(name);
	log.info("successfully connected to factory subprocess "
			+ factoryProcessName);
	return rrf;
}