Java Code Examples for java.rmi.AlreadyBoundException

@Override
public void run() {
    //напишите тут ваш код
    try {
        //создание объекта для удаленного доступа
        final Animal cat = new Cat("Barsik");
        final Animal dog = new Dog("Palkan");

        //создание реестра расшареных объетов
        registry = LocateRegistry.createRegistry(2099);

        //создание "заглушки" – приемника удаленных вызовов
        Remote stubCat = UnicastRemoteObject.exportObject(cat, 0);
        Remote stubDog = UnicastRemoteObject.exportObject(dog, 0);

        //регистрация "заглушки" в реесте
        registry.bind(BINDING_NAME1, stubCat);
        registry.bind(BINDING_NAME2, stubDog);

    } catch (RemoteException | AlreadyBoundException e) {
        e.printStackTrace();
    }
}
 

@Override protected void serviceStarted() {
    super.serviceStarted();

    String rmiServiceName = System.getProperty(PROPERTYNAME_RMISERVICENAME);
    if (rmiServiceName == null) {
        throw new IllegalStateException("system property '" + PROPERTYNAME_RMISERVICENAME+ "' を設定してください.");
    }
    try {
        TefService.instance().getRmiRegistry().bind(rmiServiceName, new MplsnmsRmiServiceAccessPoint.Impl());
    } catch (RemoteException re) {
        throw new RuntimeException(re);
    } catch (AlreadyBoundException abe) {
        throw new RuntimeException(abe);
    }

    NaefTefService.instance().getRmcServerService()
        .registerMethod(AllocateVlanIpsubnetaddr.Call.class, new AllocateVlanIpsubnetaddr.Exec());
}
 

public static void main(String[] args)
        throws RemoteException, AlreadyBoundException {
    if (args.length != 3) {
        System.out.println
                ("args: [port] [service name]"
                        + " [acceptable tef service ids (comma separated)]");
        return;
    }

    String portStr = args[0];
    String serviceName = args[1];
    String[] acceptableTefServiceIds = args[2].split(",");

    int port;
    try {
        port = Integer.parseInt(portStr);
    } catch (NumberFormatException nfe) {
        throw new IllegalArgumentException("invalid number format: port");
    }

    new Impl(port, serviceName, acceptableTefServiceIds);
}
 

@Override
protected Object doInBackground() {
    // Your Task's code here.  This method runs
    // on a background thread, so don't reference
    // the Swing GUI from here...
    String result = "stopped";
    try {
        if (canreg.common.ServerLauncher.start(Globals.DEFAULT_SERVER_ADDRESS, systemDescription.getSystemCode(), Globals.DEFAULT_PORT)) {
            result = "started";
        }
    } catch (AlreadyBoundException ex) {
        result = "running";
        Logger.getLogger(InstallNewSystemInternalFrame.class.getName()).log(Level.INFO, null, ex);
    }
    // Return your result...
    return result;
}
 

@Override
protected Object doInBackground() {
    // Your Task's code here.  This method runs
    // on a background thread, so don't reference
    // the Swing GUI from here...
    String result = "stopped";
    try {
        if (canreg.common.ServerLauncher.start(serverURLTextField.getText(), codeField.getText(), Integer.parseInt(portField.getText()))) {
            result = "started";
        } else {
            // if this fails, does that always mean this is running?
            result = "running";
        }
    } catch (AlreadyBoundException ex) {
        result = "running";
        Logger.getLogger(LoginInternalFrame.class.getName()).log(Level.INFO, null, ex);
    }
    // Return your result... 
    return result;
}
 

public ClusterImpl(ActorSystem system, String host, String seedHost) throws RemoteException {
    super();
    this.system = (AbsActorSystem) system;
    this.members = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());
    this.seed = seedHost;
    if (!host.equals(seedHost))
        this.uuid = host + "/" + UUID.randomUUID().toString().replaceAll("-", "");
    else this.uuid = host + "/master";
    try {
        Naming.bind("rmi://" + this.uuid, this);
        join(this.uuid);
        if (!host.equals(seedHost))
            updateMembers(seedHost, this.uuid);
    } catch (AlreadyBoundException | MalformedURLException e) {
        e.printStackTrace();
    }
}
 

/**
 * Entry point for the JVM forked by {@link #testSeparateJVMs()}.
 */
public static void main(String[] arguments) throws IOException, AlreadyBoundException, NotBoundException {
    LocalController localController = new LocalController();

    Registry registry = LocateRegistry.createRegistry(REGISTRY_PORT);
    Controller controller = (Controller) UnicastRemoteObject.exportObject(localController, 0);
    registry.bind(CONTROLLER, controller);

    Path lockFile = Paths.get(arguments[0]);
    RepositorySystemSession repositorySystemSession = Mockito.mock(RepositorySystemSession.class);
    try (FileLockSyncContextFactory syncContextFactory = new FileLockSyncContextFactory(lockFile)) {
        new SyncTask(syncContextFactory, localController, repositorySystemSession).run();
    }

    UnicastRemoteObject.unexportObject(localController, true);
    UnicastRemoteObject.unexportObject(registry, true);
}
 

/**
 * Create several nodes on the same JVMProcess
 */
public static List<TestNode> createNodes(final String nodeName, int number)
        throws IOException, NodeException, ExecutionException, InterruptedException, AlreadyBoundException {
    if (number == 0) {
        throw new IllegalArgumentException("" + number);
    }

    ArrayList<TestNode> nodes = new ArrayList<>(number);
    // Start the JVMProcess and create the first node
    TestNode node0 = createNode(nodeName + 0, findFreePort());
    nodes.add(0, node0);

    // create all subsequent nodes remotely
    for (int i = 1; i < number; i++) {
        Node nodei = node0.getNode().getProActiveRuntime().createLocalNode(nodeName + i, false, null);
        nodes.add(new TestNode(node0.getNodeProcess(), nodei));
    }

    return nodes;
}
 

@Test
public void server() throws RemoteException, AlreadyBoundException, InterruptedException {
	int port = 8030;
	Registry registry = LocateRegistry.createRegistry(port);

	RIImpl ro = new RIImpl();
	Remote expRO = UnicastRemoteObject.exportObject(ro, port + 1);
	registry.bind("ro", expRO);

	registry.bind("po", (PureObj) () -> {
		System.out.println("PureObj getValue");
		return 1;
	});

	int i = 1;
	while (true) {
		Thread.sleep(1_000);
		ro.v = i++;
	}
}
 

/**
 * @see Registry.bind(String, Remote)
 */
public void bind(String name, Remote obj)
        throws RemoteException, AlreadyBoundException, AccessException {
    if (name == null) {
        // rmi.5D=name could not be null.
        throw new NullPointerException(Messages.getString("rmi.5D")); //$NON-NLS-1$
    }

    if (obj == null) {
        // rmi.5C=obj could not be null.
        throw new NullPointerException(Messages.getString("rmi.5C")); //$NON-NLS-1$
    }

    if (table.containsKey(name)) {
        // rmi.5E=There is already binding to the name {0}.
        throw new AlreadyBoundException(Messages.getString("rmi.5E", name)); //$NON-NLS-1$
    }
    checkAccess("RegistryImpl.bind"); //$NON-NLS-1$
    table.put(name, obj);
}
 

public void bind(XletContext xc, String path, Remote obj)
    throws AlreadyBoundException {

    Debug("IxcRegistry.bind(" + xc + ", " + path + ", " + obj + ")");

    if (!(xc instanceof BDJXletContext) || (BDJXletContext)xc != BDJXletContext.getCurrentContext()) {
        Debug("bind(): xc not current BDJXletContext");
        throw new IllegalArgumentException("xc not current BDJXletContext");
    }
    if (((BDJXletContext)xc).isReleased()) {
        Debug("bind(): xc is destroyed");
        return;
    }

    synchronized (remoteObjects) {
        if (remoteObjects.containsKey(path))
            throw new AlreadyBoundException();
        remoteObjects.put(path, new WrappedRemoteObj(obj, (BDJXletContext)xc));
    }
}
 

/**
 * @see Registry.bind(String, Remote)
 */
public void bind(String name, Remote obj)
        throws RemoteException, AlreadyBoundException, AccessException {
    if (name == null) {
        // rmi.5D=name could not be null.
        throw new NullPointerException(Messages.getString("rmi.5D")); //$NON-NLS-1$
    }

    if (obj == null) {
        // rmi.5C=obj could not be null.
        throw new NullPointerException(Messages.getString("rmi.5C")); //$NON-NLS-1$
    }

    if (table.containsKey(name)) {
        // rmi.5E=There is already binding to the name {0}.
        throw new AlreadyBoundException(Messages.getString("rmi.5E", name)); //$NON-NLS-1$
    }
    checkAccess("RegistryImpl.bind"); //$NON-NLS-1$
    table.put(name, obj);
}
 

/**
 * @see Registry.bind(String, Remote)
 */
public void bind(String name, Remote obj)
        throws RemoteException, AlreadyBoundException, AccessException {
    if (name == null) {
        // rmi.5D=name could not be null.
        throw new NullPointerException(Messages.getString("rmi.5D")); //$NON-NLS-1$
    }

    if (obj == null) {
        // rmi.5C=obj could not be null.
        throw new NullPointerException(Messages.getString("rmi.5C")); //$NON-NLS-1$
    }

    if (table.containsKey(name)) {
        // rmi.5E=There is already binding to the name {0}.
        throw new AlreadyBoundException(Messages.getString("rmi.5E", name)); //$NON-NLS-1$
    }
    checkAccess("RegistryImpl.bind"); //$NON-NLS-1$
    table.put(name, obj);
}
 

/**
 * Creates an application including all the required EDMProv elements:
 * agent, entity and the activity of running the app, started by the
 * participant running it.
 *
 * @param participant the participant who runs the application
 * @param name the human readable name of the application
 * @param timestamp the time the application is started
 * @return the application
 */
public Application createApplication(Participant participant, String name, String timestamp) {
    Application app = new Application();
    String appName = name.trim().substring(0, 1).toUpperCase() + name.replace(" ", "").substring(1).toLowerCase();
    try {
        app.activity = participant.agent.startActivity("Using" + appName + "Activity_"
                + UUID.randomUUID(), "Using " + name + " activity", timestamp);
        app.entity = app.activity.generateEntity("app_entity_" + UUID.randomUUID(), name, timestamp);
        app.entity.addOwlClass(provFactory.getNamespaceForPrefix("eee") + "Application");
        app.agent = provFactory.createAgent("app_agent_" + UUID.randomUUID(), name);
        app.agent.addTriple(provFactory.getNamespaceForPrefix("owl") + "sameAs",
                app.entity.getIri(), EDMTriple.TRIPLE_TYPE.OBJECT_PROPERTY);
        app.agent.actOnBehalfOf(participant.agent);
        app.participant = participant;
    } catch (DataFormatException | DatatypeConfigurationException | AlreadyBoundException | NoSuchFieldException e) {
        logger.error("Error creating application", e);
        app = null;
    }
    return app;
}
 

/**
 * Make the participant use data on the client
 *
 * @param participant the participant
 * @param client the application which the participant is using
 * @param data the content which is used
 * @param dataName the name of the data to be used for labelling
 * @param timestamp the unix timestamp of this discrete useData (start=end)
 * @param duration in seconds
 * @return the useData of using the data
 */
public Activity useDataOnClient(Participant participant, Application client, Content data,
        String dataName, String timestamp, String duration) {

    Activity useData = new Activity();
    try {
        String dName = dataName.substring(0, 1).toUpperCase() + dataName.replaceAll(" ", "").substring(1);

        if (duration == null) {
            useData.activity = participant.agent.doDiscreteActivity("Use" + dName + "Activity_" + UUID.randomUUID(), "Use " + dataName, timestamp);
        } else {
            useData.activity = participant.agent.startActivity("Use" + dName + "Activity_" + UUID.randomUUID(), "Use " + dataName, timestamp);
            participant.agent.stopActivity(useData.activity, getEndTimestamp(timestamp, duration));
        }

        useData.activity.useEntity(data.entity);
        useData.activity.useEntity(client.entity);
    } catch (DataFormatException | DatatypeConfigurationException | AlreadyBoundException e) {
        logger.error("Error creating \"use data on client\" pattern", e);
    }
    return useData;
}
 

/**
 * Make a participant use a real world entity
 *
 * @param participant the participant
 * @param entity the entity to be used
 * @param timestamp the unix timestamp of this discrete useData (start=end)
 * @param duration in seconds
 *
 * @return the useData Activity of the agent using the entity
 */
public Activity useRealWorldEntity(Participant participant, Entity entity, String timestamp, String duration) {

    Activity useEntity = new Activity();
    try {

        if (duration == null) {
            useEntity.activity = participant.agent.doDiscreteActivity("UseActivity_"
                    + UUID.randomUUID(), "Use " + entity.entity.getFriendlyName(), timestamp);
        } else {
            useEntity.activity = participant.agent.startActivity("UseActivity_"
                    + UUID.randomUUID(), "Use " + entity.entity.getFriendlyName(), timestamp);
            participant.agent.stopActivity(useEntity.activity, getEndTimestamp(timestamp, duration));
        }

        useEntity.activity.useEntity(entity.entity);
    } catch (DataFormatException | DatatypeConfigurationException | AlreadyBoundException e) {
        logger.error("Error creating \"use entity\" pattern", e);
    }
    return useEntity;
}
 

/**
 * Make the participant navigate the client
 *
 * @param participant the participant
 * @param client the application which the participant is using
 * @param timestamp the unix timestamp of this discrete activity (start=end)
 * @param duration in seconds
 * @return the activity of navigating
 */
public Activity navigateClient(Participant participant, Application client, String timestamp, String duration) {

    Activity navigate = new Activity();
    try {

        if (duration == null) {
            navigate.activity = participant.agent.doDiscreteActivity("NavigateClientActitivy_"
                    + UUID.randomUUID(), "Navigate " + client.entity.getFriendlyName(), timestamp);
        } else {
            navigate.activity = participant.agent.startActivity("NavigateClientActitivy_"
                    + UUID.randomUUID(), "Navigate " + client.entity.getFriendlyName(), timestamp);
            participant.agent.stopActivity(navigate.activity, getEndTimestamp(timestamp, duration));
        }

        navigate.activity.useEntity(client.entity);
    } catch (DataFormatException | DatatypeConfigurationException | AlreadyBoundException e) {
        logger.error("Error creating \"navigate client\" pattern", e);
    }
    return navigate;
}
 

/**
 * Registers locally the given VirtualNode in a registry such RMIRegistry or HTTP registry.
 * The VirtualNode to register must exist on the local runtime. This is done when using XML Deployment Descriptors
 * @param virtualNode the VirtualNode to register.
 * @param registrationProtocol The protocol used for registration or null in order to use the protocol used to start the jvm.
 * At this time RMI, HTTP, IBIS are supported. If set to null, the registration protocol will be set to the system property:
 * proactive.communication.protocol
 * @param replacePreviousBinding
 * @throws ProActiveException If the VirtualNode with the given name has not been yet activated or does not exist on the local runtime
 */
public static void registerVirtualNode(VirtualNode virtualNode, String registrationProtocol,
        boolean replacePreviousBinding) throws ProActiveException, AlreadyBoundException {
    if (!(virtualNode instanceof VirtualNodeImpl)) {
        throw new ProActiveException("Cannot register such virtualNode since it results from a lookup!");
    }
    if (registrationProtocol == null) {
        registrationProtocol = CentralPAPropertyRepository.PA_COMMUNICATION_PROTOCOL.getValue();
    }
    String virtualnodeName = virtualNode.getName();
    ProActiveRuntime part = RuntimeFactory.getProtocolSpecificRuntime(registrationProtocol);
    VirtualNodeInternal vn = part.getVirtualNode(virtualnodeName);
    if (vn == null) {
        throw new ProActiveException("VirtualNode " + virtualnodeName +
            " has not been yet activated or does not exist! Try to activate it first !");
    }
    part.registerVirtualNode(URIBuilder.appendVnSuffix(virtualnodeName), replacePreviousBinding);
}
 

/** Creates a new node on the local ProActive runtime.
 * 
 * @param nodeName 
 * 			name of the node to create. It musts comply to the following regular expression: "[a-zA-Z0-9_-]+"
 * @param replacePreviousBinding
 * 			Should an already existing node with the same name be replaced or not			
 * @param psm
 * 			A {@link ProActiveSecurityManager} or null
 * @param vnname
 * 			A Virtual Node name or null
 * @return  the newly created node on the local JVM
 * @exception NodeException 
 * 			if the node cannot be created or if the nodeName is invalid
 */
public static Node createLocalNode(String nodeName, boolean replacePreviousBinding,
        ProActiveSecurityManager psm, String vnname) throws NodeException, AlreadyBoundException {
    ProActiveRuntime proActiveRuntime;

    // Throws an Exception is the name is invalid
    checkNodeName(nodeName);

    if (logger.isDebugEnabled()) {
        logger.debug("NodeFactory: createNode(" + nodeName + ")");
    }

    if (vnname == null) {
        vnname = DEFAULT_VIRTUAL_NODE_NAME;
    }

    //NodeFactory factory = getFactory(protocol);
    //then create a node
    try {
        proActiveRuntime = RuntimeFactory.getDefaultRuntime();
        return proActiveRuntime.createLocalNode(nodeName, replacePreviousBinding, psm, vnname);
    } catch (Exception e) {
        throw new NodeException("Failed to create a local node. name=" + nodeName, e);
    }
}
 

/*******************
 * Check if the given endpoint can be attacked.
 * 
 * This check is performed by executing a dummy attack against the
 * endpoint and observing the resulting exception.
 * 
 * @param ep An enumerated RMI endpoint.
 * @return True if we can attack it.
 ******************/
public boolean canAttackEndpoint(RMIEndpoint ep) {
	RMIBindExploitProxy proxy = null;
	Registry reg;
	
	//Execute a dummy attack
	try {
		//Start a bind exploit proxy
		proxy = new RMIBindExploitProxy(InetAddress.getByName(ep.getEndpoint().getHost()), ep.getEndpoint().getPort(), this._options, this._dummyPayload);
		proxy.startProxy();
		
		//Get a proxied RMI registry reference
		reg = LocateRegistry.getRegistry(proxy.getServerListenAddress().getHostAddress(), proxy.getServerListenPort());
		
		//Bind a dummy object in an attempt to trigger the vulnerability
		reg.bind(this.generateRandomString(), new BaRMIeBindExploit());
	} catch(BaRMIeException | UnknownHostException | RemoteException | AlreadyBoundException ex) {
		//An up to date RMI registry will, by default, reject the dummy object
		if(ex instanceof ServerException && ex.getCause() != null && ex.getCause() instanceof UnmarshalException && ex.getCause().getCause() != null && ex.getCause().getCause() instanceof InvalidClassException) {
			//Check for "filter status: REJECTED"
			if(ex.getCause().getCause().toString().contains("filter status: REJECTED")) {
				//Test payload was filtered, likely this attack isn't possible
				return false;
			}
		}
	} finally {
		//Stop the proxy
		if(proxy != null) {
			proxy.stopProxy(true);
		}
	}
	
	//In all other cases we should be able to attack the registry
	return true;
}
 

public void bind(String name, Remote obj)
    throws RemoteException, AlreadyBoundException, AccessException
{
    if (name.equals(NAME)) {
        throw new AccessException(
            "binding ActivationSystem is disallowed");
    } else {
        super.bind(name, obj);
    }
}
 

public void bind(String name, Remote obj)
    throws RemoteException, AlreadyBoundException, AccessException
{
    if (name.equals(NAME)) {
        throw new AccessException(
            "binding ActivationSystem is disallowed");
    } else {
        super.bind(name, obj);
    }
}
 

@Test(dataProvider="bindData")
public void simpleBind(String name, Remote obj, boolean blacklisted) throws RemoteException, AlreadyBoundException, NotBoundException {
    try {
        registry.bind(name, obj);
        Assert.assertFalse(blacklisted, "Registry filter did not reject (but should have) ");
        registry.unbind(name);
    } catch (Exception rex) {
        Assert.assertTrue(blacklisted, "Registry filter should not have rejected");
    }
}
 

@Test
public void simpleRejectableClass() throws RemoteException, AlreadyBoundException, NotBoundException {
    RejectableClass r1 = null;
    try {
        String name = "reject1";
        r1 = new RejectableClass();
        registry.bind(name, r1);
        registry.unbind(name);
        Assert.assertNull(registryFilter, "Registry filter should not have rejected");
    } catch (Exception rex) {
        Assert.assertNotNull(registryFilter, "Registry filter should have rejected");
    }
}
 

public void bind(String name, Remote obj)
    throws RemoteException, AlreadyBoundException, AccessException
{
    if (name.equals(NAME)) {
        throw new AccessException(
            "binding ActivationSystem is disallowed");
    } else {
        RegistryImpl.checkAccess("ActivationSystem.bind");
        super.bind(name, obj);
    }
}
 

@Test(dataProvider="bindData")
public void simpleBind(String name, Remote obj, boolean blacklisted) throws RemoteException, AlreadyBoundException, NotBoundException {
    try {
        registry.bind(name, obj);
        Assert.assertFalse(blacklisted, "Registry filter did not reject (but should have) ");
        registry.unbind(name);
    } catch (Exception rex) {
        Assert.assertTrue(blacklisted, "Registry filter should not have rejected");
    }
}
 

@Test
public void simpleRejectableClass() throws RemoteException, AlreadyBoundException, NotBoundException {
    RejectableClass r1 = null;
    try {
        String name = "reject1";
        r1 = new RejectableClass();
        registry.bind(name, r1);
        registry.unbind(name);
        Assert.assertNull(registryFilter, "Registry filter should have rejected");
    } catch (Exception rex) {
        Assert.assertNotNull(registryFilter, "Registry filter should not have rejected");
    }
}
 

@Test
public void simpleDepthBuiltinNonRejectable() throws RemoteException, AlreadyBoundException, NotBoundException {
    int depthOverride = Integer.getInteger("test.maxdepth", REGISTRY_MAX_DEPTH);
    depthOverride = Math.min(depthOverride, REGISTRY_MAX_DEPTH);
    System.out.printf("overrideDepth: %d, filter: %s%n", depthOverride, registryFilter);
    try {
        String name = "reject2";
        DepthRejectableClass r1 = DepthRejectableClass.create(depthOverride);
        registry.bind(name, r1);
        registry.unbind(name);
    } catch (Exception rex) {
        Assert.fail("Registry filter should not have rejected depth: "
                        + depthOverride);
    }
}
 

@Test
public void simpleDepthRejectable() throws RemoteException, AlreadyBoundException, NotBoundException {
    int depthOverride = Integer.getInteger("test.maxdepth", REGISTRY_MAX_DEPTH);
    depthOverride = Math.min(depthOverride, REGISTRY_MAX_DEPTH);
    System.out.printf("overrideDepth: %d, filter: %s%n", depthOverride, registryFilter);
    try {
        String name = "reject3";
        DepthRejectableClass r1 = DepthRejectableClass.create(depthOverride + 1);
        registry.bind(name, r1);
        Assert.fail("Registry filter should have rejected depth: " + depthOverride + 1);
    } catch (Exception rex) {
        // Rejection expected
    }
}
 

Impl(int port, String serviceName, String[] acceptableTefServiceIds)
        throws RemoteException, AlreadyBoundException {
    synchronized (Impl.class) {
        if (instance__ != null) {
            throw new IllegalStateException();
        } else {
            instance__ = this;
        }
    }

    Logs logs = new Logs(System.currentTimeMillis(), new File("."), "logs");
    transactionCoordinationLogger_ = logs.createLogger("distributed-transactions");

    tefServices_ = new HashMap<String, TefServiceProxy>();
    for (String acceptableTefServiceId : acceptableTefServiceIds) {
        tefServices_.put(acceptableTefServiceId, null);
    }

    tefServiceIndexes_ = new HashMap<String, Integer>();
    for (int i = 0; i < acceptableTefServiceIds.length; i++) {
        tefServiceIndexes_.put(acceptableTefServiceIds[i], new Integer(i));
    }

    try {
        history_
                = restoreTxHistory(transactionCoordinationLogger_.getFile().getParentFile());
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }

    System.out.println("restored: " + history_.size());
    System.gc();
    long memoryUsage
            = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
    System.out.println("memory: " + NumberFormat.getInstance().format(memoryUsage));

    Registry registry = LocateRegistry.createRegistry(port);
    registry.bind(serviceName, this);
}
 

public void bind(String name, Remote obj)
    throws RemoteException, AlreadyBoundException, AccessException
{
    if (name.equals(NAME)) {
        throw new AccessException(
            "binding ActivationSystem is disallowed");
    } else {
        super.bind(name, obj);
    }
}
 

public Registry publish(Registry registry, String identifier, int port) throws RemoteException, AccessException, AlreadyBoundException {
	final StringProviderMXBean stub = (StringProviderMXBean) UnicastRemoteObject.exportObject(this, port);
	// RemoteServer.setLog(System.out);
	// Bind the remote object's stub in the registry
	registry.bind(identifier, stub);
	LOG.info("Stringprovider service '{}' published on port {}.", identifier, port);
	return registry;
}
 

public void publish(Registry registry, String identifier, int port) throws RemoteException, AlreadyBoundException {
	LOG.info("Trying to publish Language model service '{}' on port {}.", identifier, port);
	@SuppressWarnings("unchecked")
	final LanguageModelServerMBean<String> stub = (LanguageModelServerMBean<String>) UnicastRemoteObject.exportObject(this, port);
	// RemoteServer.setLog(System.out);
	// Bind the remote object's stub in the registry
	registry.bind(identifier, stub);
	LOG.info("Language model service '{}' published on port {}.", identifier, port);
}
 

/**
 * 
 * @param args
 */
public static void main(String[] args) {
    try {
        if (args.length >= 1) {
            start("localhost", args[0], 1199);
        }
    } catch (AlreadyBoundException ex) {
        Logger.getLogger(ServerLauncher.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

/**
 * Public constructor, in case of an {@code ActorRef} of type
 * {@code ActorMode.REMOTE} bind the name to the RMI registry.
 */
public AbsActorRef(ActorSystem system, ActorMode mode, String name) throws RemoteException {
    super();
    this.system = (AbsActorSystem) system;
    this.name = name;
    this.originalSender = this;
    if (this.system.getSystemMode() == SystemMode.CLUSTER) {
        try {
            Naming.bind("rmi://" + name, this);
        } catch (AlreadyBoundException | MalformedURLException e) {
            e.printStackTrace();
        }
    }
}
 

private static void launch() throws URISyntaxException, AlreadyBoundException, IOException, InterruptedException, NotBoundException  {
//    initialize the log writer that hydra uses
    LogWriter log = Log.createLogWriter( "dunit-master", LOG_LEVEL );

    locatorPort = AvailablePortHelper.getRandomAvailableTCPPort();
     
    //create an RMI registry and add an object to share our tests config
    int namingPort = AvailablePortHelper.getRandomAvailableTCPPort();
    Registry registry = LocateRegistry.createRegistry(namingPort);
    Master master = new Master();
    registry.bind(MASTER_PARAM, master);

    final ProcessManager processManager = new ProcessManager(NUM_VMS + 1, namingPort);

    Runtime.getRuntime().addShutdownHook(new Thread() {
      public void run() {
        processManager.killVMs();
      }
    });
    
    //launch the remote VMS
    processManager.launchVMs();
    
    //wait for the VMS to start up
    if(!master.waitForVMs(STARTUP_TIMEOUT)) {
      throw new RuntimeException("VMs did not start up with 30 seconds");
    }
    
    //populate the Host class with our stubs. The tests use this host class
    EclipseDUnitHost host = new EclipseDUnitHost(InetAddress.getLocalHost().getCanonicalHostName(), NUM_VMS);
    host.init(registry);

    initSystemProperties(log);
    
    startLocator(registry);
  }
 

public void bind(String name, Remote obj)
    throws RemoteException, AlreadyBoundException, AccessException
{
    if (name.equals(NAME)) {
        throw new AccessException(
            "binding ActivationSystem is disallowed");
    } else {
        super.bind(name, obj);
    }
}
 

@Test(dataProvider="bindData")
public void simpleBind(String name, Remote obj, boolean blacklisted) throws RemoteException, AlreadyBoundException, NotBoundException {
    try {
        registry.bind(name, obj);
        Assert.assertFalse(blacklisted, "Registry filter did not reject (but should have) ");
        registry.unbind(name);
    } catch (Exception rex) {
        Assert.assertTrue(blacklisted, "Registry filter should not have rejected");
    }
}
 

@Test
public void simpleRejectableClass() throws RemoteException, AlreadyBoundException, NotBoundException {
    RejectableClass r1 = null;
    try {
        String name = "reject1";
        r1 = new RejectableClass();
        registry.bind(name, r1);
        registry.unbind(name);
        Assert.assertNull(registryFilter, "Registry filter should not have rejected");
    } catch (Exception rex) {
        Assert.assertNotNull(registryFilter, "Registry filter should have rejected");
    }
}
 

public DHTRingMaster(ZooKeeperConfig zkConfig, String dhtName, 
                      long intervalMillis, Mode mode, boolean enableLogging) throws IOException, KeeperException, AlreadyBoundException {
    mc = new MetaClient(dhtName, zkConfig);
    convergenceControllers = new ConcurrentHashMap<>();
    this.intervalMillis = intervalMillis;
    this.mode = mode;
    mp = mc.getMetaPaths();
    this.zkConfig = zkConfig;
    convergenceLock = new ReentrantLock();
    /*
     * The below VersionWatcher watches the DHTConfiguration for changes. Whenever a new DHTConfiguration
     * is observed, a new RingConfigWatcher is started.
     */
    dhtConfigWatcher = new DHTConfigurationWatcher(zkConfig, dhtName, intervalMillis, enableLogging);
    this.enableLogging = enableLogging;
    
    dhtRingCurTargetZK = new DHTRingCurTargetZK(mc, dhtConfig);
    
    ringChangedWorker = new RingChangedWorker();
    recoverDataWorker = new RecoverDataWorker();
    
    dhtMetaReader = new DHTMetaReader(zkConfig, dhtName, enableLogging);
    
    mgBase = new MessageGroupBase(mgBasePort, this, SystemTimeUtil.systemTimeSource, null, 
    							  queueLimit, numSelectorControllers, selectorControllerClass);
    mode = Mode.Automatic;
    new RingMasterControlImpl(this);
}