JvnServerImpl.java

Go to the documentation of this file.

package jvn;

import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.io.*;

import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

public class JvnServerImpl      extends UnicastRemoteObject implements JvnLocalServer, JvnRemoteServer{
        private static final long serialVersionUID = -1834717182805714127L;

        private static JvnServerImpl js = null;

        private HashMap<Integer,JvnObject> jvnObjectIds = null;

        private JvnRemoteCoord jvnCoordinator = null;

        private JvnServerImpl() throws Exception {
                jvnObjectIds = new HashMap<Integer,JvnObject>();
                try {
                        jvnCoordinator = (JvnRemoteCoord)Naming.lookup("AT_LD_jvnCoordinator");
                } catch(NotBoundException e) {
                        System.out.println("Coordinator not found!");
                        jvnCoordinator = null;
                }
        }

        public static JvnServerImpl jvnGetServer() {
                if (js == null) {
                        try {
                                js = new JvnServerImpl();
                        } catch (Exception e) {
                                System.out.println("Error creating the Javanaise Server!\n"+e);
                                return null;
                        }
                }
                return js;
        }

        public void jvnTerminate() throws jvn.JvnException {
                JvnRemoteCoord coord = null;
                synchronized(this) {
                        if(jvnCoordinator!=null) {
                                coord = jvnCoordinator;
                                jvnCoordinator = null;
                        }
                }

                System.out.println("Terminating the Javanaise Server");

                try {
                        if (coord != null) {
                                coord.jvnServerTerminated(this);
                        }
                } catch (RemoteException e) {}
        }

        public JvnObject jvnCreateObject(Serializable o)
        throws jvn.JvnException {
                return new JvnObjectImpl(o);
        }

        public void jvnRegisterObject(String jon, JvnObject jo) throws jvn.JvnException {
                if(jvnCoordinator == null) {
                        throw new JvnException("Coordinator is not present!");
                } else if(jo == null || jon == null) {
                        throw new JvnException("The given name or JvnObject is not valid!");
                } else {
                        try {
                                int id = jvnCoordinator.jvnGetObjectId();
                                jo.jvnSetObjectId(id);
                                jvnCoordinator.jvnRegisterObject(jon,jo,this);

                                // Only put in cache after successful registration
                                jvnObjectIds.put(id,jo);
                        } catch (RemoteException e) {
                                throw new JvnException("Network error while registering object!\n" + e);
                        }
                }
        }

        public JvnObject jvnLookupObject(String jon, Class<? extends JvnObject> type) throws jvn.JvnException {
                /*if(jvnCoordinator == null) {
                        throw new JvnException("Coordinator is not present!");
                }*/
                if (jon == null) {
                        throw new JvnException("The given name is not valid!");
                }
                if (type == null) {
                        throw new JvnException("The given class type is not valid!");
                }
                else {
                        try {
                                //System.out.println(type.getName());
                                JvnObject temp = jvnCoordinator.jvnLookupObject(jon, type, this);
                                //System.out.println(temp);
                                if (temp != null) {
                                        // A Javanaise object with name <jon> exists.
                                        
                                        // String-comparison-based type checking !
                                        if (temp.toString().startsWith(type.getName())) {
//                                      if (temp.getClass().getName().startsWith(type.getName())) {
                                                try {
                                                        // Try typecast...
                                                        // This is supposed to handle JvnObject vs. JvnObjectImpl,
                                                        // which string-comparison-based type checking cannot do
                                                        // cleanly.
                                                        temp.getClass().asSubclass(type);
                                                        // The Javanaise object with name <jon> has the same type as the
                                                        // given type, so we assume that it is the same object.
                                                        jvnObjectIds.put(temp.jvnGetObjectId(), temp);
                                                        ((JvnObjectImpl)temp).__containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                                                }
                                                catch (ClassCastException e) {
                                                        System.err.println(type.getName());
                                                        System.err.println(temp.toString());
                                                        throw new JvnException("Object with same name, but different type, previously registered (2)!");
                                                }
                                                
                                        }
                                        else {
                                                // Rare case: there is already a Javanaise object with name <jon>,
                                                // but the type of that object is different from the given type...
                                                // Trying to use the previously registered object may trigger all
                                                // kinds of exceptions: ClassCastException, NoSuchMethodException, etc.
                                                // We'd better signaling there's a problem.
                                                System.err.println(type.getName());
                                                System.err.println(temp.toString());
                                                throw new JvnException("Object with same name, but different type, previously registered (1)!");
                                        }
                                }
                                
                                //try {
                                        //c = (type.class)o;
                                        //type.class temp = (JvnObject)o;
                                        //if (o instanceof c)
                                        //Class.forName(className)
                                        if(temp!=null) {
                                        }
                                        return temp;
                                //}
                        } catch(RemoteException e) {
                                throw new JvnException("Network error!\n"+e);
                        } catch(ClassCastException e) {
                                throw new JvnException("Unexpected class type!");
                        }
                }
        }

        public Serializable jvnLockRead(int joi) throws JvnException {
                if(jvnCoordinator == null) {
                        throw new JvnException("Coordinator is not present!");
                } else if( jvnObjectIds.containsKey(joi) ) {
                        try {
                                return jvnCoordinator.jvnLockRead(joi,this);
                        } catch (RemoteException e) {
                                throw new JvnException("Network error while locking object for reading!\n" + e);
                        }
                } else {
                        throw new JvnException("Unknown object ID! Plase call jvnLookupObject before calling this method!");
                }
        }
        public Serializable jvnLockWrite(int joi) throws JvnException {
                if(jvnCoordinator == null) {
                        throw new JvnException("Coordinator is not present!");
                } else if( jvnObjectIds.containsKey(joi) ) {
                        try {
                                return jvnCoordinator.jvnLockWrite(joi,this);
                        } catch (RemoteException e) {
                                throw new JvnException("Network error while locking object for reading!\n" + e);
                        }
                } else {
                        throw new JvnException("Unknown object ID! Plase call jvnLookupObject before calling this method!");
                }
        }


        public void jvnInvalidateReader(int joi) throws java.rmi.RemoteException,jvn.JvnException {
                JvnObject jo = jvnObjectIds.get(joi);

                if( jo==null ) {
                        throw new JvnException("Object id not found while invalidating reader!");
                } else {
                        jo.jvnInvalidateReader();
                }
        }

        public Serializable jvnInvalidateWriter(int joi) throws java.rmi.RemoteException,jvn.JvnException {
                JvnObject jo = jvnObjectIds.get(joi);

                if( jo==null ) {
                        throw new JvnException("Object id not found while invalidating reader!");
                } else {
                        return jo.jvnInvalidateWriter();
                }
        }

        public Serializable jvnInvalidateWriterForReader(int joi) throws java.rmi.RemoteException,jvn.JvnException {
                JvnObject jo = jvnObjectIds.get(joi);

                if( jo==null ) {
                        throw new JvnException("Object id not found while invalidating reader!");
                } else {
                        return jo.jvnInvalidateWriterForReader();
                }
        }
}

---