public void stopServer() { try { registry.unbind(SERVICE_NAME); UnicastRemoteObject.unexportObject(registry, true); } catch (Exception e) { e.printStackTrace(); } }
@Override protected MavenRemoteServer create() throws RemoteException { MavenRemoteServer server; try { server = client.acquire(this, ""); } catch (Exception e) { throw new RemoteException("Can't start maven server", e); } if (!loggerExported) { Remote loggerRemote = UnicastRemoteObject.exportObject(rmiLogger, 0); if (!(loggerExported = loggerRemote != null)) { throw new RemoteException("Can't export logger"); } } if (!listenerExported) { Remote listenerRemote = UnicastRemoteObject.exportObject(rmiDownloadListener, 0); if (!(listenerExported = listenerRemote != null)) { throw new RemoteException("Can't export download listener"); } } server.configure(rmiLogger, rmiDownloadListener); return server; }
public static void main(String[] args) throws Exception { System.err.println("\nRegression test for bug 4513223\n"); Remote impl2 = null; try { Remote impl = new MarshalAfterUnexport2(); System.err.println("created impl extending URO (with a UnicastServerRef2): " + impl); Receiver stub = (Receiver) RemoteObject.toStub(impl); System.err.println("stub for impl: " + stub); UnicastRemoteObject.unexportObject(impl, true); System.err.println("unexported impl"); impl2 = new MarshalAfterUnexport2(); Receiver stub2 = (Receiver) RemoteObject.toStub(impl2); System.err.println("marshalling unexported object:"); MarshalledObject mobj = new MarshalledObject(impl); System.err.println("passing unexported object via RMI-JRMP:"); stub2.receive(stub); System.err.println("TEST PASSED"); } finally { if (impl2 != null) { try { UnicastRemoteObject.unexportObject(impl2, true); } catch (Throwable t) { } } } }
/** Stop. */ public void stop() { this.lookupTask.stop(); if (this.stub != null) { try { this.reg.unbind(this.bindingName); this.dist.unexportClients(); this.dist.unexportServer(); UnicastRemoteObject.unexportObject(this.dist, true); } catch (RemoteException rex) { logger.warning(rex.getMessage()); } catch (NotBoundException nbex) { logger.warning(nbex.getMessage()); } } try { UnicastRemoteObject.unexportObject(this.reg, true); } catch (NoSuchObjectException ex) { ex.printStackTrace(); } }
/* ------------------------------------------------------------------------------------------------------ * Main Method for the application * ------------------------------------------------------------------------------------------------------ */ public static void main(String[] args) { // Check of the security manager is installed, if not se it. if (System.getSecurityManager() == null) { System.setSecurityManager(new SecurityManager()); } try { // Locate the RMI registry Registry registry = LocateRegistry.getRegistry(); // Create the Player object ref in the registry and bind it Players players = new Players(); PlayerInterface stubPlayer = (PlayerInterface) UnicastRemoteObject.exportObject(players, 3001); Naming.rebind("rmi://localhost/Players", players); // Similar process for shapes. Shapes Hello = new Shapes(); ShapeInterface stub = (ShapeInterface) UnicastRemoteObject.exportObject(Hello, 3001); Naming.rebind("rmi://localhost/Shapes", Hello); // Confirm to the console the server is ready System.out.println("2Draw Server is ready."); } catch (Exception e) { System.out.println("2Draw Server failed: " + e); e.printStackTrace(); } }
public void shutdown() { try { if (UnicastRemoteObject.unexportObject(this, false)) return; Thread.sleep(5000); UnicastRemoteObject.unexportObject(this, true); } catch (Exception e) { // nothing to do .. we're shutting down ... } }
public static void main(String[] args) throws Exception { System.err.println("\nRegression test for bug 6261402\n"); System.setProperty( "java.rmi.activation.port", Integer.toString(TestLibrary.INHERITEDCHANNELNOTSERVERSOCKET_ACTIVATION_PORT)); RMID rmid = null; Callback obj = null; try { /* * Export callback object and bind in registry. */ System.err.println("export callback object and bind in registry"); obj = new CallbackImpl(); Callback proxy = (Callback) UnicastRemoteObject.exportObject(obj, 0); Registry registry = LocateRegistry.createRegistry(TestLibrary.INHERITEDCHANNELNOTSERVERSOCKET_REGISTRY_PORT); registry.bind("Callback", proxy); /* * Start rmid. */ System.err.println("start rmid with inherited channel"); RMID.removeLog(); rmid = RMID.createRMID( System.out, System.err, true, true, TestLibrary.INHERITEDCHANNELNOTSERVERSOCKET_ACTIVATION_PORT); rmid.addOptions( new String[] { "-Djava.nio.channels.spi.SelectorProvider=" + "InheritedChannelNotServerSocket$SP" }); rmid.start(); /* * Get activation system and wait to be notified via callback * from rmid's selector provider. */ System.err.println("get activation system"); ActivationSystem system = ActivationGroup.getSystem(); System.err.println("ActivationSystem = " + system); synchronized (lock) { while (!notified) { lock.wait(); } } System.err.println("TEST PASSED"); } finally { if (obj != null) { UnicastRemoteObject.unexportObject(obj, true); } ActivationLibrary.rmidCleanup(rmid); } }
public void deploy(URL url, boolean master, ClassLoader cL, String remoteHost) { try { FileObject filetoScan = fsManager.resolveFile("jar:" + url.toString() + "!/"); HashSet<Class<?>>[] classes = new HashSet[] {new HashSet()}; VFSClassLoader jarCL; if (cL != null) { jarCL = new VFSClassLoader(new FileObject[] {filetoScan}, fsManager, cL); } else { jarCL = new VFSClassLoader( new FileObject[] {filetoScan}, fsManager, Thread.currentThread().getContextClassLoader()); } Class[] annot = new Class[] {DeployRMI.class}; scanJar(filetoScan, classes, annot, jarCL); for (Class<?> rmiClass : classes[0]) { DeployRMI rmiAnnot = rmiClass.getAnnotation(DeployRMI.class); if (master) { rmiProxyHandler = new RMIProxyHandler(rmiAnnot.jndiBinding(), remoteObjects); rmiproxy = Proxy.newProxyInstance( rmiClass.getClassLoader(), rmiClass.getInterfaces(), rmiProxyHandler); remoteobj = UnicastRemoteObject.exportObject( (Remote) rmiproxy, Integer.parseInt(serverConfig.getRmiregistryport())); rmiproxyObjs.put(rmiAnnot.jndiBinding(), rmiproxy); rmiproxyHandler.put(rmiAnnot.jndiBinding(), rmiProxyHandler); remoteProxyObjs.put(rmiAnnot.jndiBinding(), remoteobj); ic.bind("java:/" + rmiAnnot.jndiBinding(), remoteobj); registry.bind(rmiAnnot.jndiBinding(), (Remote) remoteobj); cLMap.put(rmiAnnot.jndiBinding(), jarCL); } else { Remote remoteObj = (Remote) rmiClass.newInstance(); remoteSlaveObjs.put(rmiAnnot.jndiBinding(), remoteObj); Object remoteobj = UnicastRemoteObject.exportObject( (Remote) remoteObj, Integer.parseInt(serverConfig.getRmiregistryport())); ic.bind("java:/" + rmiAnnot.jndiBinding(), remoteobj); registry.bind(rmiAnnot.jndiBinding(), (Remote) remoteobj); if (remoteObjects.get(rmiAnnot.jndiBinding()) != null) { ConcurrentMap<String, Remote> remoteObjs = remoteObjects.get(rmiAnnot.jndiBinding()); remoteObjs.put(remoteHost, (Remote) remoteobj); } else { ConcurrentHashMap<String, Remote> remoteObjs = new ConcurrentHashMap<String, Remote>(); remoteObjs.put(remoteHost, (Remote) remoteobj); remoteObjects.put(rmiAnnot.jndiBinding(), remoteObjs); } } } } catch (Exception e) { log.error("unable to deploy the package " + url, e); } }
public static void main(String[] args) throws Exception { System.err.println("\nRegression test for RFE 4010355\n"); ServerStackTrace impl = new ServerStackTrace(); try { Ping stub = (Ping) UnicastRemoteObject.exportObject(impl); StackTraceElement[] remoteTrace; try { __FOO__(stub); throw new RuntimeException("TEST FAILED: no exception caught"); } catch (PingException e) { System.err.println("trace of exception thrown by remote call:"); e.printStackTrace(); System.err.println(); remoteTrace = e.getStackTrace(); } int fooIndex = -1; int barIndex = -1; for (int i = 0; i < remoteTrace.length; i++) { StackTraceElement e = remoteTrace[i]; if (e.getMethodName().equals("__FOO__")) { if (fooIndex != -1) { throw new RuntimeException("TEST FAILED: " + "trace contains more than one __FOO__"); } fooIndex = i; } else if (e.getMethodName().equals("__BAR__")) { if (barIndex != -1) { throw new RuntimeException("TEST FAILED: " + "trace contains more than one __BAR__"); } barIndex = i; } } if (fooIndex == -1) { throw new RuntimeException("TEST FAILED: trace lacks client-side method __FOO__"); } if (barIndex == -1) { throw new RuntimeException("TEST FAILED: trace lacks server-side method __BAR__"); } if (fooIndex < barIndex) { throw new RuntimeException( "TEST FAILED: trace contains client-side method __FOO__ " + "before server-side method __BAR__"); } System.err.println("TEST PASSED"); } finally { try { UnicastRemoteObject.unexportObject(impl, true); } catch (Exception e) { } } }
/** * Exports the referenced Remote interface-implementing object for remote access through RMI. * Returns true on success, or false if the underlying exportObject() call threw a * RemoteException. */ public boolean publishObject(Remote obj) { try { if (useSSL) { UnicastRemoteObject.exportObject(obj, this.port, this.csf, this.ssf); } else { UnicastRemoteObject.exportObject(obj, this.port); } return true; } catch (RemoteException ex) { return false; } }
/** * Removes the Remote obj reference from remote accessiblity. Once this call returns, the obj will * not receive any more remote RMI calls. If force is true, the object will be unpublished even if * there are pending calls on it. * * <p>Returns true on successful unpublish, or false if there was some problem. */ public boolean unpublishObject(Remote obj, boolean force) { try { return UnicastRemoteObject.unexportObject(obj, force); } catch (NoSuchObjectException ex) { return false; } }
/** * Start. * * @return true, if successful */ public boolean start() { reg = null; // Create or connect to the registry try { reg = this.regInfo.connect(this.initRegistry); this.dist = new Distributor(this); this.stub = (IDistributor) UnicastRemoteObject.exportObject(dist, 0); reg.bind(this.bindingName, this.stub); } catch (RemoteException rex) { logger.severe("Remote error: " + rex.getMessage()); return false; } catch (AlreadyBoundException abex) { logger.severe( "The binding name \"" + this.bindingName + "\" is already in use. Maybe this server is already started?"); return false; } logger.info("\"" + this.bindingName + "\" started up"); this.lookupTask.start(); return true; }
@AdviseWith(adviceClasses = {PropsUtilAdvice.class}) @Test public void testClassInitializationOnSPI() throws Exception { System.setProperty(PropsKeys.INTRABAND_IMPL, SelectorIntraband.class.getName()); System.setProperty(PropsKeys.INTRABAND_TIMEOUT_DEFAULT, "10000"); System.setProperty(PropsKeys.INTRABAND_WELDER_IMPL, SocketWelder.class.getName()); MPI mpiImpl = _getMPIImpl(); Assert.assertNotNull(mpiImpl); Assert.assertTrue(mpiImpl.isAlive()); MPI mpi = MPIHelperUtil.getMPI(); Assert.assertSame(mpi, UnicastRemoteObject.toStub(mpiImpl)); Assert.assertTrue(mpi.isAlive()); Intraband intraband = MPIHelperUtil.getIntraband(); Assert.assertSame(SelectorIntraband.class, intraband.getClass()); DatagramReceiveHandler[] datagramReceiveHandlers = intraband.getDatagramReceiveHandlers(); Assert.assertSame( BootstrapRPCDatagramReceiveHandler.class, datagramReceiveHandlers[SystemDataType.RPC.getValue()].getClass()); }
/** Instanciação e Inicialização do ZonaDesembarqueRegister */ public ZonaDesembarqueRegister() { super(); canEnd = false; try { registry = LocateRegistry.getRegistry(registryHostname, registryPort); log = (LoggingInterface) registry.lookup("Logging"); } catch (RemoteException e) { GenericIO.writelnString("Excepção na localização do Logging: " + e.getMessage() + "!"); e.printStackTrace(); System.exit(1); } catch (NotBoundException e) { GenericIO.writelnString("O Logging não está registado: " + e.getMessage() + "!"); e.printStackTrace(); System.exit(1); } desembarque = new ZonaDesembarque(log, this); try { desembarqueInterface = (ZonaDesembarqueInterface) UnicastRemoteObject.exportObject( desembarque, portNumber[Globals.MON_ZONA_DESEMBARQUE]); } catch (RemoteException e) { System.exit(1); } }
@AdviseWith(adviceClasses = {PropsUtilAdvice.class}) @Test public void testShutdownFailWithoutLog() throws NoSuchObjectException { UnicastRemoteObject.unexportObject(_getMPIImpl(), true); final IOException ioException = new IOException(); ReflectionTestUtil.setFieldValue( MPIHelperUtil.class, "_intraband", new MockIntraband() { @Override public void close() throws IOException { throw ioException; } }); try (CaptureHandler captureHandler = JDKLoggerTestUtil.configureJDKLogger(MPIHelperUtil.class.getName(), Level.OFF)) { MPIHelperUtil.shutdown(); List<LogRecord> logRecords = captureHandler.getLogRecords(); Assert.assertTrue(logRecords.isEmpty()); } }
public static void main(String args[]) { AnnuaireIF annuaire = new Annuaire(); try { UnicastRemoteObject.exportObject(annuaire, 0); } catch (RemoteException e) { System.out.println("Lancé de nain lors de l'export de l'objet !"); e.printStackTrace(); System.exit(0); } Registry registry = null; try { registry = LocateRegistry.createRegistry(5500); // registry = LocateRegistry.getRegistry("localhost", 5500); } catch (RemoteException e) { System.out.println("Lancé de nain lors de la localisation de registry !"); e.printStackTrace(); System.exit(0); } try { registry.bind("Annuaire", annuaire); } catch (RemoteException | AlreadyBoundException e) { System.out.println("Lancé de nain lors du bind !"); e.printStackTrace(); System.exit(0); } System.out.println("Serveur lancé sans lancé de nain !"); } // fin du main
public static void main(String args[]) { // Figure out where server is running String server = "localhost"; try { // create a new Server object FlightRM obj = new FlightRM(); // dynamically generate the stub (client proxy) ResourceManager rm = (ResourceManager) UnicastRemoteObject.exportObject(obj, 0); // Bind the remote object's stub in the registry Registry registry = LocateRegistry.getRegistry(8778); registry.rebind("Group4FlightRM", rm); System.err.println("Flight Server ready"); } catch (Exception e) { System.err.println("Server exception: " + e.toString()); e.printStackTrace(); } // Create and install a security manager /* if (System.getSecurityManager() == null) { System.setSecurityManager(new RMISecurityManager()); } */ }
private Creator() throws RemoteException { Registry registry = LocateRegistry.createRegistry(1099); controllerImpl = new RemoteController() { @Override public void previewClosed() throws RemoteException { preview.setSelected(false); } @Override public void ready() throws RemoteException { SwingUtilities.invokeLater( new Runnable() { public void run() { initiateRemoteUIDefaults(); } }); } @Override public void setTabIndex(int index) throws RemoteException { previewIndex = index; } }; RemoteController controller = (RemoteController) UnicastRemoteObject.exportObject(controllerImpl, 0); registry.rebind(RemoteController.class.getName(), controller); }
void register(String hostName, final int rmiPort, final int serverPort) { try { final ManagementImpl impl = (ManagementImpl) _persistit.getManagement(); if (hostName == null && rmiPort != -1) { try { if (hostName == null) { final InetAddress addr = InetAddress.getLocalHost(); try { hostName = addr.getHostName() + ":" + rmiPort; } catch (final Exception e) { hostName = addr.getHostAddress() + ":" + rmiPort; } } } catch (final NumberFormatException nfe) { } } if (rmiPort != -1 && _localRegistryPort != rmiPort) { LocateRegistry.createRegistry(rmiPort); _localRegistryPort = rmiPort; } if (hostName != null && hostName.length() > 0) { final String name = "//" + hostName + "/PersistitManagementServer"; UnicastRemoteObject.exportObject(impl, serverPort); Naming.rebind(name, impl); impl._registered = true; impl._registeredHostName = hostName; _persistit.getLogBase().rmiServerRegistered.log(hostName); } } catch (final Exception exception) { _persistit.getLogBase().rmiRegisterException.log(hostName, exception); } }
private static void publicizeRmiInterface(ModuleManager m, int registry_port) throws RemoteException { ModuleManagerRemote remote = (ModuleManagerRemote) UnicastRemoteObject.exportObject(m, 0); Registry reg = LocateRegistry.createRegistry(registry_port); logger.info("java RMI registry created."); reg.rebind(RMI_SERVER_NAME, remote); }
public static void main(String[] args) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(1024); KeyPair par = keyGen.generateKeyPair(); prk = par.getPrivate(); pbk = par.getPublic(); Registry reg = null; System.out.println("Creando conexion remota"); try { reg = LocateRegistry.createRegistry(5555); } catch (Exception e) { e.printStackTrace(); } System.out.println("Creando objeto servidor"); Servidor s = new Servidor(); try { reg.rebind("Operaciones", (InterfaceRemota) UnicastRemoteObject.exportObject(s, 0)); } catch (Exception e) { e.printStackTrace(); } while (true) { try { Thread.sleep(1000); } catch (InterruptedException ex) { Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex); } } }
public static void main(String[] args) { /** Atenção: Esses dois parametros são de grande importancia. */ String enderecoIPLocal = "127.0.0.1"; String nomeServidor = "Servidor"; int porta = 2020; /* * ######################## */ System.out.println("Objeto remoto no endereco " + enderecoIPLocal); try { Servidor banco = new Servidor(); // cria o registry para evitar problemas. Registry registry = LocateRegistry.createRegistry(porta); ServidorRemoto stubRemoto = (ServidorRemoto) UnicastRemoteObject.exportObject(banco, 0); String uriServidorRemoto = "rmi://" + nomeServidor; registry.rebind(uriServidorRemoto, stubRemoto); System.out.println("Objeto remoto exportado com nome " + uriServidorRemoto); System.out.println("\nObjeto remoto servidor do ar!"); } catch (RemoteException e) { e.printStackTrace(); System.exit(0); } }
public static void main(String args[]) { /* * Create and install a security manager */ // if (System.getSecurityManager() == null) { // System.setSecurityManager(new SecurityManager()); // } byte pattern = (byte) 0xAC; try { /* * Create remote object and export it to use * custom socket factories. */ HelloImpl obj = new HelloImpl(); RMIClientSocketFactory csf = new XorClientSocketFactory(pattern); RMIServerSocketFactory ssf = new XorServerSocketFactory(pattern); Hello stub = (Hello) UnicastRemoteObject.exportObject(obj, 0, csf, ssf); /* * Create a registry and bind stub in registry. */ LocateRegistry.createRegistry(2002); Registry registry = LocateRegistry.getRegistry(2002); registry.rebind("Hello", stub); System.out.println("HelloImpl bound in registry"); } catch (Exception e) { System.out.println("HelloImpl exception: " + e.getMessage()); e.printStackTrace(); } }
public void init(List serviceList, ServerConfig serverConfig, MBeanServer mbeanServer) { System.setProperty("java.io.tmpdir", serverConfig.getCachedir()); try { this.serviceList = serviceList; this.serverConfig = serverConfig; this.mbeanServer = mbeanServer; fsManager.init(); } catch (Exception e) { log.error("Unable to initialie file system: " + fsManager, e); } try { registry = LocateRegistry.createRegistry(Integer.parseInt(serverConfig.getRmiregistryport())); ic = new InitialContext(); Context subctx = null; try { subctx = (Context) ic.lookup("java:"); } catch (Exception ex) { log.error("initializing the java context", ex); // ex.printStackTrace(); } if (subctx == null) { ic.createSubcontext("java:"); } remoteBindingInterface = new RemoteBindingObject(ic); Object jndilookupobj = UnicastRemoteObject.exportObject( remoteBindingInterface, Integer.parseInt(serverConfig.getRmiregistryport())); registry.rebind("RemoteBindingObject", (Remote) jndilookupobj); } catch (Exception ex) { log.error("error in registring to the remote binding object", ex); // e1.printStackTrace(); } log.info("initialized"); }
public static void main(String args[]) throws Exception { try { testPkg.Server obj = new testPkg.Server(); testPkg.Hello stub = (testPkg.Hello) UnicastRemoteObject.exportObject(obj, 0); // Bind the remote object's stub in the registry Registry registry = LocateRegistry.getRegistry(TestLibrary.READTEST_REGISTRY_PORT); registry.bind("Hello", stub); System.err.println("Server ready"); // now, let's test client testPkg.Client client = new testPkg.Client(TestLibrary.READTEST_REGISTRY_PORT); String testStubReturn = client.testStub(); if (!testStubReturn.equals(obj.hello)) { throw new RuntimeException("Test Fails : unexpected string from stub call"); } else { System.out.println("Test passed"); } registry.unbind("Hello"); } catch (Exception e) { System.err.println("Server exception: " + e.toString()); e.printStackTrace(); } }
public RemotePersonImpl(String name, String surname, String passportNumber) throws RemoteException { this.name = name; this.surname = surname; this.passportNumber = passportNumber; accounts = new ConcurrentHashMap<String, Account>(); UnicastRemoteObject.exportObject(this, 0); }
/** * Method exports and (re)binds a remote object with the registry * * @param name * @param obj * @return * @throws RemoteException * @throws AlreadyBoundException * @throws AccessException */ public static Remote rebindService(String name, Remote obj) throws RemoteException, AlreadyBoundException, AccessException { Remote stub = UnicastRemoteObject.exportObject(obj, 0); checkStartRegistry().rebind(name, stub); System.out.println("ServiceUtil: Service '" + name + "' bound."); return stub; }
static { Remote remote; try { remote = UnicastRemoteObject.exportObject(ourCook, 0); } catch (RemoteException e) { throw new IllegalStateException(e); } ourHand = remote; }
void shutdownSpi() { server.stop(); try { UnicastRemoteObject.unexportObject(this.debugger, true); } catch (Exception e) { } RmiDebuggedEnvironmentImpl.cleanup(); }
private void stopRegistry() { if (_registry != null) { try { UnicastRemoteObject.unexportObject(_registry, true); } catch (Exception ex) { LOG.ignore(ex); } } }