Examples of com.sun.sgs.app.DataManager

com.sun.sgs.app.DataManager
Provides facilities for managing access to shared, persistent objects. Managed objects are objects that implement the {@link ManagedObject} and{@link Serializable} interfaces. Each managed object is stored separatelyalong with all of the serializable, non-managed objects it refers to. If a managed object refers to another managed object, it must do so through an instance of {@link ManagedReference}, created by the {@link #createReference createReference} method. Attempting to store a reference to a managedobject using a standard reference rather than an instance of ManagedReference will typically result in an {@link ObjectIOException} being thrown when the current transaction commits.
Managed objects that are bound to names, and any managed objects they refer to directly or indirectly, are stored by the DataManager. It is up to the application to determine when managed objects are no longer needed and to remove them explicitly from the DataManager using the {@link #removeObject removeObject} method.
Managed objects are in one of the following states with respect to the data manager:
- Transient - A managed object that has been created directly by the application and has not been supplied in a call to {@link #setBinding setBinding}, {@code createReference}, or {@link #getObjectId getObjectId}. Transient objects are not known to the data manager and are not stored persistently.
  Passing a transient object to {@code setBinding}, {@code createReference}, or {@code getObjectId} creates a new entry for theobject in the data manager. Calling {@code removeObject} or {@link #markForUpdate markForUpdate} on a transient object does not change thestate of the object. If a transient object implements {@link ManagedObjectRemoval}, though, then calling {@code removeObject} willcause its {@link ManagedObjectRemoval#removingObject removingObject}method to be called.
- Persistent - A managed object that has been stored in the data manager by calling {@code setBinding}, {@code createReference}, or {@code getObjectId} in the current transaction, orelse retrieved from the data manager by calling {@link #getBinding getBinding}, {@link #getBindingForUpdate getBindingForUpdate}, {@link ManagedReference#get ManagedReference.get}, or {@link ManagedReference#getForUpdate ManagedReference.getForUpdate}.
  Passing a persistent object to {@code setBinding}, {@code createReference}, {@code markForUpdate}, or {@code getObjectId} does notcreate a new entry for that object in the data manager, but rather reuses the existing one. Calling {@code removeObject} on a persistentobject removes it from the data manager, meaning it will no longer be stored persistently, and changes its state to removed. Note that a managed object made persistent in the current transaction is automatically marked for update, so there is no need to call {@code markForUpdate} for such objects, in particular in theirconstructors.
- Removed - A managed object that has been removed from the data manager by calling {@code removeObject}. Removed objects are no longer stored persistently, although the data manager makes an effort to track which managed objects have been removed.
  Only persistent managed objects can become removed; calling {@code removeObject} on a transient managed object leaves it as a transientobject. Passing a removed managed object to {@code setBinding}, {@code removeObject}, {@code markForUpdate}, {@code createReference}, or {@code getObjectId}, as well as calling {@code ManagedReference.get} or {@code ManagedReference.getForUpdate} on a reference to the removed object,will cause a {@link ObjectNotFoundException} to be thrown, if the systemhas tracked the object's removed state.
- Stale - A managed object that was persistent or removed in another, completed transaction. Stale objects are objects that have become detached from the data manager, and should not be visible to applications that avoid using static fields, but may be encountered under some circumstances. The data manager implementation may or may not track stale objects. If stale objects are not tracked, they will be considered transient.
  Passing a stale object to {@code setBinding}, {@code removeObject}, {@code markForUpdate}, {@code createReference}, or {@code getObjectId}, as well as calling {@code ManagedReference.get} or {@code ManagedReference.getForUpdate} on a reference to the stale object, willcause a {@link TransactionNotActiveException} to be thrown, if thesystem has tracked the object's stale state.
Because storing a managed object in a name binding or creating a managed reference to it causes the object to be stored in data manager, applications should insure that they remove such objects if they end up not referring to them persistently. The {@code removeObject} method does not throwexceptions when called on a transient object, so applications should call {@code removeObject} whenever there is an object that may have becomepersistent and they are sure is no longer used.
Some implementations may need to be notified when managed objects and the objects they refer to are modified, while other implementations may be configurable to detect these modifications automatically. Applications are always permitted to mark objects that have been modified, and doing so may produce performance improvements regardless of whether modifications are detected automatically. @see AppContext#getDataManager @see ManagedObject @see ManagedReference @see Serializable

      }
  }


  /** Removes some entries, returning true if there is more to do. */
  private boolean doWork() {
      DataManager dataManager = AppContext.getDataManager();
      dataManager.markForUpdate(this);
            ScalableHashMap<K, V> node = currentNodeRef.get();
      /* Find the leaf node */
      if (!node.isLeafNode()) {
    while (true) {
        currentNodeRef =
      uncheckedCast(node.nodeDirectory[offsets.peek()]);
        node = currentNodeRef.get();
        if (node.isLeafNode()) {
      break;
        }
        offsets.push(0);
    }
      }
      if (!node.removeSomeLeafEntries()) {
    /* More entries in this node */
    return true;
      }
      /* Search the parents for a non-empty node, removing empty ones */
      while (true) {
    currentNodeRef = node.parentRef;
    dataManager.removeObject(node);
    if (currentNodeRef == null) {
        break;
    }
    int offset = offsets.pop();
    node = currentNodeRef.get();

View Full Code Here

   * @param v the value
   */
  PrefixEntry(int h, K k, V v) {
      this.hash = h;


      DataManager dm = AppContext.getDataManager();


      // if both the key and value are not ManagedObjects, we can save a
      // get() and createReference() call each by merging them in a
      // single KeyValuePair
      if (!(k instanceof ManagedObject) &&
    !(v instanceof ManagedObject))
      {
    setKeyValuePair();
    keyOrPairRef = dm.createReference(
        new ManagedSerializable<Object>(
                        new KeyValuePair<K, V>(k, v)));
      } else {
    // For the key and value, if each is already a ManagedObject,
    // then we obtain a ManagedReference to the object itself,
    // otherwise, we need to wrap it in a ManagedSerializable and
    // get a ManagedReference to that
    setKeyWrapped(!(k instanceof ManagedObject));
    keyOrPairRef = dm.createReference(
        isKeyWrapped() ? new ManagedSerializable<Object>(k) : k);
    setValueWrapped(!(v instanceof ManagedObject));
    valueRef = dm.createReference(
        isValueWrapped() ? new ManagedSerializable<V>(v) : v);
      }
  }

View Full Code Here

   * value.
   *
   * @param newValue the value to be stored
   */
  void setValueInternal(V newValue) {
      DataManager dm = AppContext.getDataManager();
      if (newValue instanceof ManagedObject) {
    if (isKeyValuePair()) {
        /* Switch from wrapping key/value pair to wrapping key */
                    ManagedSerializable<KeyValuePair<K, V>> msPair =
      uncheckedCast(keyOrPairRef.get());
        ManagedSerializable<K> msKey =
      uncheckedCast(keyOrPairRef.get());
        msKey.set(msPair.get().getKey());
        setKeyWrapped(true);
    } else if (isValueWrapped()) {
        dm.removeObject(valueRef.get());
        setValueWrapped(false);
    }
    valueRef = dm.createReference(newValue);
      } else if (isKeyValuePair()) {
                ManagedSerializable<KeyValuePair<K, V>> msPair =
        uncheckedCast(keyOrPairRef.get());
    msPair.get().setValue(newValue);
      } else if (isKeyWrapped()) {
    /* Switch from wrapping key to wrapping key/value pair */
    ManagedSerializable<K> msKey =
        uncheckedCast(keyOrPairRef.get());
                ManagedSerializable<KeyValuePair<K, V>> msPair =
        uncheckedCast(keyOrPairRef.get());
                msPair.set(new KeyValuePair<K, V>(msKey.get(), newValue));
    if (isValueWrapped()) {
        dm.removeObject(valueRef.get());
    }
    setKeyValuePair();
      } else if (isValueWrapped()) {
    ManagedSerializable<V> ms = uncheckedCast(valueRef.get());
    ms.set(newValue);
      } else {
    valueRef = dm.createReference(
        new ManagedSerializable<V>(newValue));
    setValueWrapped(true);
      }
  }

View Full Code Here

   * ScalableHashMap#remove ScalableHashMap.remove}, or {@link #remove
   * remove} under the condition that this entry's map-managed object
   * will never be referenced again by the map.
   */
  final void unmanage() {
      DataManager dm = AppContext.getDataManager();


      if (isKeyValuePair()) {
    try {
        dm.removeObject(keyOrPairRef.get());
    } catch (ObjectNotFoundException onfe) {
        // silent
    }
      } else {
    if (isKeyWrapped()) {
        try {
      dm.removeObject(keyOrPairRef.get());
        } catch (ObjectNotFoundException onfe) {
      // silent
        }
    }
    if (isValueWrapped()) {
        try {
      dm.removeObject(valueRef.get());
        } catch (ObjectNotFoundException onfe) {
      // silent
        }
    }
      }

View Full Code Here

     * Get an instance of the PlacemarkRegistrySrv class
     * @return a shared instance of Darkstar web login
     */
    public static PlacemarkRegistrySrv getInstance() {
        PlacemarkRegistrySrv out;
        DataManager dm = AppContext.getDataManager();


        try {
            out = (PlacemarkRegistrySrv) dm.getBinding(BINDING_NAME);
        } catch (NameNotBoundException nnbe) {
            out = createInstance();
            dm.setBinding(BINDING_NAME, out);
        }


        return out;
    }

View Full Code Here

     *          January 1, 1970, or {@code TaskServiceImpl.START_NOW}
     * @param p the period between recurrences, or
     *          {@code TaskServiceImpl.PERIOD_NONE}
     */
    void resetValues(Task t, long s, long p) {
        DataManager dm = AppContext.getDataManager();
        dm.markForUpdate(this);


        /* If the Task is also a ManagedObject then the assumption is
           that the object was already managed by the application so we
           just keep a reference...otherwise, we make it part of our
           state, which has the effect of persisting the task. In either
           case we set one of the two fields to null to disambiguate
           what the situation is. */
        if (t instanceof ManagedObject) {
            taskRef = dm.createReference(t); 
            task = null;
        } else {
            task = t;
            taskRef = null;
        }

View Full Code Here

        {
            this.type     = type;
            this.clientID = clientID;
        
            // create references
            DataManager dm = AppContext.getDataManager();
            channelRef     = dm.createReference(channel);
        }

View Full Code Here

        public ConnectionType getClientType() {
            return type;
        }


        public Set<WonderlandClientID> getClients() {
            DataManager dm = AppContext.getDataManager();
            Set<WonderlandClientID> out = new LinkedHashSet<WonderlandClientID>();


            for (Iterator<ClientSession> i = channelRef.get().getSessions();
                 i.hasNext();)
            {
                ManagedReference<ClientSession> ref = dm.createReference(i.next());
                out.add(new WonderlandClientID(ref));
            }
            
            return out;
        }

View Full Code Here

                // special case -- force ID of internal handler
                assignID = SessionInternalConnectionType.SESSION_INTERNAL_CLIENT_ID;
            }
            
            // create a ClientSessionSet and channel
            DataManager dm = AppContext.getDataManager();
            ChannelManager cm = AppContext.getChannelManager();
            
            ClientSessionSet sessions = new ClientSessionSet();
            String channelName = handler.getConnectionType().toString() + 
                                 "(" + String.valueOf(assignID) + ")";
            Channel channel = cm.createChannel(channelName, 
                                               null,
                                               Delivery.RELIABLE);


            // mark ourself for udate
            dm.markForUpdate(this);


            // add to the map
            HandlerRecord record = new HandlerRecord();
            record.ref = ref;
            record.channel  = dm.createReference(channel);
            record.sessions = dm.createReference(sessions);
            record.clientID = assignID;
            handlers.put(handler.getConnectionType(), record);
            
            return record.clientID;
        }

View Full Code Here

         * Unregister a handler
         * @param handler the handler to unregister
         */
        public void unregister(ClientConnectionHandler handler) {
            // mark ourself for udate
            DataManager dm = AppContext.getDataManager();
            dm.markForUpdate(this);


            HandlerRecord record = handlers.remove(handler.getConnectionType());
  
            // remove the channel and session store
            dm.removeObject(record.channel.get());
            dm.removeObject(record.sessions.get());
            
            // clear the reference, which will remove a managed object
            // handler from the data store
            if (record != null) {
                record.ref.clear();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.sun.sgs.app.DataManager

com.sun.sgs.app.util.ScalableDeque

com.sun.sgs.app.util.ScalableDeque$Element

com.sun.sgs.app.util.ScalableHashMap

com.sun.sgs.app.util.ScalableHashMap$PrefixEntry

com.sun.sgs.app.util.ScalableHashMap$RemoveNodesTask

com.sun.sgs.app.util.ScalableList

com.sun.sgs.app.util.ScalableList$AsynchronousClearTask

com.sun.sgs.app.util.ScalableList$ListNode

com.sun.sgs.app.util.ScalableList$TreeNode

com.sun.sgs.impl.kernel.KernelContext

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.