jvn.JvnCoordImpl Class Reference

Inheritance diagram for jvn.JvnCoordImpl:

[legend]

Collaboration diagram for jvn.JvnCoordImpl:

[legend]

List of all members.

Public Member Functions
int	jvnGetObjectId () throws java.rmi.RemoteException,jvn.JvnException
void	jvnRegisterObject (String jon, JvnObject jo, JvnRemoteServer js) throws java.rmi.RemoteException,jvn.JvnException
JvnObject	jvnLookupObject (String jon, Class<?extends JvnObject > type, JvnRemoteServer js) throws java.rmi.RemoteException,jvn.JvnException
Serializable	jvnLockRead (int joi, JvnRemoteServer js) throws java.rmi.RemoteException, JvnException
Serializable	jvnLockWrite (int joi, JvnRemoteServer js) throws java.rmi.RemoteException, JvnException
void	jvnServerTerminated (JvnRemoteServer js) throws RemoteException, JvnException
Static Public Member Functions
static void	main (String argv[]) throws Exception
Private Member Functions
	JvnCoordImpl () throws Exception
Private Attributes
int	currID = -1
HashMap< String, JvnServers >	jvnServersOfNames = new HashMap<String, JvnServers>()
HashMap< Integer, JvnServers >	jvnServersOfIdentifiers = new HashMap<Integer, JvnServers>()
Static Private Attributes
static final long	serialVersionUID = -115305878534728396L
static JvnCoordImpl	jo = null

---

Detailed Description

This class implements the Javanaise Coordinator. Internally, it will use RMI to communicate with the JvnServer interfaces.

Definition at line 132 of file JvnCoordImpl.java.

---

Constructor & Destructor Documentation

jvn.JvnCoordImpl.JvnCoordImpl

(

)

throws Exception [private]

Default constructor. Will rebind itself with the RMI registry.

Definition at line 168 of file JvnCoordImpl.java.

References jvn.JvnCoordImpl.currID.

Referenced by jvn.JvnCoordImpl.main().

                                                {
                Naming.rebind("AT_LD_jvnCoordinator", this);
                System.out.println("Javanaise Coordinator is ready.");
                currID = 0;
        }

Here is the caller graph for this function:

---

Member Function Documentation

static void jvn.JvnCoordImpl.main

(

String

argv[]

)

throws Exception [static]

This is the main method. Its content is empty since the only thing it needs to do is done by the constructor.

Exceptions:

	Exception
	IOException

Definition at line 180 of file JvnCoordImpl.java.

References jvn.JvnCoordImpl.jo, and jvn.JvnCoordImpl.JvnCoordImpl().

                                                                {
                if(jo==null){
                        jo = new JvnCoordImpl();
                        System.out.println("Press ENTER to terminate the Javanaise Coordinator.");
                        try {
                                System.in.read();
                        } catch (IOException e) {}
                }
        }

Here is the call graph for this function:

int jvn.JvnCoordImpl.jvnGetObjectId

(

)

throws java.rmi.RemoteException,jvn.JvnException

Gets a new object ID. Object IDs are unique for each coordinator.

Implements jvn.JvnRemoteCoord.

Definition at line 193 of file JvnCoordImpl.java.

References jvn.JvnCoordImpl.currID.

Referenced by jvn.JvnCoordImpl.jvnRegisterObject().

                                                         {
                synchronized(this) {
                        return (++currID);
                }
        }

Here is the caller graph for this function:

void jvn.JvnCoordImpl.jvnRegisterObject	(	String	jon,
		JvnObject	jo,
		JvnRemoteServer	js
	)			throws java.rmi.RemoteException,jvn.JvnException

Associate a symbolic name with a JVN object.

Parameters:

	jon	: the JVN object name
	jo	: the JVN object
	js	: the remote reference of the JVNServer

See also:

JvnCoordImpl.jvnLookupObject(String, JvnRemoteServer)

Implements jvn.JvnRemoteCoord.

Definition at line 209 of file JvnCoordImpl.java.

References jvn.JvnCoordImpl.jo, jvn.JvnCoordImpl.jvnGetObjectId(), jvn.JvnCoordImpl.jvnServersOfIdentifiers, jvn.JvnCoordImpl.jvnServersOfNames, and jvn.JvnServers.lockState.

                                                        {
                // No one synchronizes on jvnServersOfNames,
                // synchronize on jvnServersOfIdentifiers
                synchronized(jvnServersOfIdentifiers) {

                        // Verify stuff
                        if( jo==null ) {
                                throw new JvnException("Invalid object!");
                        } else if( jo.jvnGetObjectId() < 0 ) {
                                throw new JvnException( "Invalid object ID! Please call jvnGetObjectId " +
                                                                                "to get a new object ID and associate it with the " +
                                                                                "Javanaise object using the jvnSetObjectId method." );
                        } else if( jvnServersOfIdentifiers.containsKey(jo.jvnGetObjectId()) ) {
                                throw new JvnException("Object with such an ID is already registered with this coordinator!");
                        } else if( jvnServersOfNames.containsKey(jon) ) {
                                throw new JvnException("Object with such a name is already registered with this coordinator!");
                        }

                        System.out.println("Registering object \""+jon+"\" (Object ID: "+jo.jvnGetObjectId()+")");

                        // All verifications are done, add to lists.
                        JvnServers servers = new JvnServers(js,jo);
                        servers.lockState = JvnObjectState.STATE_WLOCKT;
                        jvnServersOfNames.put(jon, servers);
                        jvnServersOfIdentifiers.put(jo.jvnGetObjectId(), servers);
                }
        }

Here is the call graph for this function:

JvnObject jvn.JvnCoordImpl.jvnLookupObject	(	String	jon,
		Class<?extends JvnObject >	type,
		JvnRemoteServer	js
	)			throws java.rmi.RemoteException,jvn.JvnException

Get the reference of a JVN object managed by a given JVN server. The returned JVN object doesn't have any lock, therefore a JvnObject#jvnLockRead() or a JvnObject#jvnLockWrite() must be done after you get the reference.

Parameters:

	jon	: the JVN object name
	js	: the remote reference of the JVNServer

Implements jvn.JvnRemoteCoord.

Definition at line 247 of file JvnCoordImpl.java.

References jvn.JvnServers.jvnObject, jvn.JvnCoordImpl.jvnServersOfIdentifiers, and jvn.JvnCoordImpl.jvnServersOfNames.

                                                        {
                // Verify arguments
                if( js==null ) {
                        throw new JvnException( "Invalid server! When calling this method " +
                                                                        "from a JvnRemoteServer, set the second "+
                                                                        "argument to \"this\".");
                }

                System.out.println("Looked up object: "+jon);

                // No one synchronizes on jvnServersOfNames,
                // synchronize on jvnServersOfIdentifiers
                synchronized(jvnServersOfIdentifiers) {
                        JvnServers servers = jvnServersOfNames.get(jon);
                        if( servers != null ) {
                                System.out.println("Found object with name \"" + jon + "\"");
                                return servers.jvnObject;
                        } else {
                                System.out.println("Not found object with name \"" + jon + "\"");
                                return null;
                        }
                }
        }

Serializable jvn.JvnCoordImpl.jvnLockRead	(	int	joi,
		JvnRemoteServer	js
	)			throws java.rmi.RemoteException, JvnException

Get a read lock on a JVN object for a given JVN server.

Parameters:

	joi	: the JVN object identification
	js	: the remote reference of the server

Returns:

the current JVN object state

Implements jvn.JvnRemoteCoord.

Definition at line 280 of file JvnCoordImpl.java.

References jvn.JvnRemoteServer.jvnInvalidateWriterForReader(), jvn.JvnServers.jvnListOfServers, jvn.JvnCoordImpl.jvnServersOfIdentifiers, jvn.JvnServers.latestJvnObjectContent, and jvn.JvnServers.lockState.

                                                     {
                // Verify arguments
                if( js==null ) {
                        throw new JvnException( "Invalid server! When calling this method " +
                                                                        "from a JvnRemoteServer, set the second "+
                                                                        "argument to \"this\".");
                }

                synchronized(jvnServersOfIdentifiers)
                {
                        JvnServers servers = jvnServersOfIdentifiers.get(joi);
                        if( servers == null ) {
                                throw new JvnException( "The given object identifier is not registered" +
                                "with this coordinator!" );
                        } else if( servers.lockState == JvnObjectState.STATE_NOLOCK ) {
                                // No lock, just read lock and set the only reference
                                System.out.println("Read lock: getting lock (was not locked before).");
                                servers.lockState = JvnObjectState.STATE_RLOCKT;
                                servers.jvnListOfServers.clear();
                                servers.jvnListOfServers.add(js);
                        } else if( servers.lockState == JvnObjectState.STATE_RLOCKT ) {
                                // Read lock, just add a reference
                                System.out.println("Read lock: adding reference.");
                                servers.jvnListOfServers.add(js);
                        } else if( servers.lockState == JvnObjectState.STATE_WLOCKT ) {
                                try {
                                        System.out.println("Read lock: invalidating writer for reader.");
                                        JvnRemoteServer server = servers.jvnListOfServers.iterator().next();
                                        servers.latestJvnObjectContent = server.jvnInvalidateWriterForReader(joi);
                                        servers.lockState = JvnObjectState.STATE_RLOCKT;
                                        if( server.equals(js)) {
                                                System.out.println("Read lock: downgraded from write lock.");
                                        } else {
                                                System.out.println("Read lock: adding reference.");
                                                servers.jvnListOfServers.add(js);
                                        }
                                } catch( Exception e ) {
                                        // This will catch all kinds of stuff, including null pointers
                                        throw new JvnException("Error getting the read lock!\n"+e);
                                }
                        } else {
                                throw new JvnException("Unexpected lock state: " + servers.lockState + " !\n");
                        }

                        return servers.latestJvnObjectContent;
                }
        }

Here is the call graph for this function:

Serializable jvn.JvnCoordImpl.jvnLockWrite	(	int	joi,
		JvnRemoteServer	js
	)			throws java.rmi.RemoteException, JvnException

Get a Write lock on a JVN object for a given JVN server.

Parameters:

	joi	: the JVN object identification
	js	: the remote reference of the server

Returns:

the current JVN object state

Implements jvn.JvnRemoteCoord.

Definition at line 337 of file JvnCoordImpl.java.

References jvn.JvnServers.jvnListOfServers, jvn.JvnCoordImpl.jvnServersOfIdentifiers, jvn.JvnServers.latestJvnObjectContent, and jvn.JvnServers.lockState.

                                                     {
                // Verify arguments
                if( js==null ) {
                        throw new JvnException( "Invalid server! When calling this method " +
                                                                        "from a JvnRemoteServer, set the second "+
                                                                        "argument to \"this\".");
                }

                synchronized(jvnServersOfIdentifiers)
                {
                        JvnServers servers = jvnServersOfIdentifiers.get(joi);
                        if( servers == null ) {
                                throw new JvnException( "The given object identifier is not registered" +
                                                                                "with this coordinator!" );
                        } else if( servers.lockState == JvnObjectState.STATE_NOLOCK ) {
                                // No lock, just read lock
                                System.out.println("Write lock: getting lock (was not locked before).");
                                servers.lockState = JvnObjectState.STATE_WLOCKT;
                        } else if( servers.lockState == JvnObjectState.STATE_RLOCKT ) {
                                System.out.println("Write lock: invalidating readers.");
                                // Get back the read lock from all servers
                                int numberOfReaders = 0;
                                Semaphore s = new Semaphore(0);

                                Iterator<JvnRemoteServer> i = servers.jvnListOfServers.iterator();
                                while(i.hasNext()) {
                                        numberOfReaders++;
                                        (new JvnInvalidateReaderThread(s,i.next(),joi)).start();
                                }

                                // Wait for all threads to end
                                if( numberOfReaders>0 ) {
                                        try {
                                                s.acquire(numberOfReaders);
                                        } catch (InterruptedException e) {}
                                }
                                System.out.println("Write lock: invalidated "+numberOfReaders+" readers.");
                        } else if( servers.lockState == JvnObjectState.STATE_WLOCKT ) {
                                try {
                                        // Write-locked, request object
                                        System.out.println("Write lock: invalidating writer.");
                                        servers.latestJvnObjectContent = servers.jvnListOfServers.iterator().next().jvnInvalidateWriter(joi);
                                        System.out.println("Write lock: invalidated writer.");
                                } catch( Exception e ) {
                                        throw new JvnException("Error getting the write lock!\n"+e);
                                }
                        } else {
                                throw new JvnException("Unexpected lock state: "+servers.lockState+" !\n");
                        }

                        servers.jvnListOfServers.clear();
                        servers.jvnListOfServers.add(js);
                        servers.lockState = JvnObjectState.STATE_WLOCKT;

                        return servers.latestJvnObjectContent;
                }
        }

void jvn.JvnCoordImpl.jvnServerTerminated

(

JvnRemoteServer

js

)

throws RemoteException, JvnException

Called when a Javanaise Server has terminated, will remove all references to that server.

Parameters:

joi

: the remote reference of the server

Implements jvn.JvnRemoteCoord.

Definition at line 402 of file JvnCoordImpl.java.

References jvn.JvnObject.jvnInvalidateWriter(), jvn.JvnServers.jvnListOfServers, jvn.JvnServers.jvnObject, jvn.JvnCoordImpl.jvnServersOfIdentifiers, jvn.JvnServers.latestJvnObjectContent, and jvn.JvnServers.lockState.

                                                                                                 {
                // All verifications are done, add to lists.
                // No one synchronizes on jvnServersOfNames,
                // synchronize on jvnServersOfIdentifiers
                System.out.println("A server has terminated: unregistering.");

                synchronized(jvnServersOfIdentifiers) {
                        Iterator<JvnServers> i = jvnServersOfIdentifiers.values().iterator();
                        Iterator<JvnRemoteServer> j = null;
                        JvnRemoteServer server = null;
                        JvnServers servers = null;

                        // Loop on the list of registered objects
                        while(i.hasNext()) {
                                servers = i.next();
                                j = servers.jvnListOfServers.iterator();

                                // Loop on the list of servers
                                while(j.hasNext()) {
                                        server = j.next();

                                        // Server found! Invalidate...
                                        if(server.equals(js)) {
                                                if(servers.lockState == JvnObjectState.STATE_WLOCKT) {
                                                        System.out.println("A server has terminated: invalidating writer.");
                                                        servers.latestJvnObjectContent = servers.jvnObject.jvnInvalidateWriter();
                                                }
                                                servers.jvnListOfServers.remove(server);
                                                if(servers.jvnListOfServers.isEmpty()) {
                                                        servers.lockState = JvnObjectState.STATE_NOLOCK;
                                                }
                                                break;
                                        }
                                }
                        }
                }
                System.out.println("A server has terminated: unregister complete.");
        }

Here is the call graph for this function:

---

Member Data Documentation

final long jvn.JvnCoordImpl.serialVersionUID = -115305878534728396L [static, private]

Automatically generated serial version ID

Definition at line 136 of file JvnCoordImpl.java.

int jvn.JvnCoordImpl.currID = -1 [private]

Current object ID, -1 means an error.

See also:

JvnRemoteCoord.jvnGetObjectId()

JvnObject.jvnGetObjectId()

Definition at line 144 of file JvnCoordImpl.java.

Referenced by jvn.JvnCoordImpl.JvnCoordImpl(), and jvn.JvnCoordImpl.jvnGetObjectId().

JvnCoordImpl jvn.JvnCoordImpl.jo = null [static, private]

A Javanaise Coordinator is managed as a singleton

Definition at line 149 of file JvnCoordImpl.java.

Referenced by jvn.JvnCoordImpl.jvnRegisterObject(), and jvn.JvnCoordImpl.main().

HashMap<String,JvnServers> jvn.JvnCoordImpl.jvnServersOfNames = new HashMap<String, JvnServers>() [private]

Map that remembers which server(s) hold a copy of an object identified with a given name.

Definition at line 155 of file JvnCoordImpl.java.

Referenced by jvn.JvnCoordImpl.jvnLookupObject(), and jvn.JvnCoordImpl.jvnRegisterObject().

HashMap<Integer,JvnServers> jvn.JvnCoordImpl.jvnServersOfIdentifiers = new HashMap<Integer, JvnServers>() [private]

Map that remembers which server(s) hold a copy of an object identified with a given object ID.

See also:

JvnObject.jvnGetObjectId()

Definition at line 163 of file JvnCoordImpl.java.

Referenced by jvn.JvnCoordImpl.jvnLockRead(), jvn.JvnCoordImpl.jvnLockWrite(), jvn.JvnCoordImpl.jvnLookupObject(), jvn.JvnCoordImpl.jvnRegisterObject(), and jvn.JvnCoordImpl.jvnServerTerminated().

---

The documentation for this class was generated from the following file:

• JvnCoordImpl.java

---