Java UnknownGroupException类代码示例

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
/**
 * Returns the group entry for the group id, optionally removing it.
 * Throws UnknownGroupException if the group is not registered.
 */
private GroupEntry getGroupEntry(ActivationGroupID id, boolean rm)
    throws UnknownGroupException
{
    if (id.getClass() == ActivationGroupID.class) {
        GroupEntry entry;
        if (rm) {
            entry = groupTable.remove(id);
        } else {
            entry = groupTable.get(id);
        }
        if (entry != null && !entry.removed) {
            return entry;
        }
    }
    throw new UnknownGroupException("group unknown");
}
 

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
synchronized void activeGroup(ActivationInstantiator inst,
                              long instIncarnation)
    throws ActivationException, UnknownGroupException
{
    if (incarnation != instIncarnation) {
        throw new ActivationException("invalid incarnation");
    }

    if (group != null) {
        if (group.equals(inst)) {
            return;
        } else {
            throw new ActivationException("group already active");
        }
    }

    if (child != null && status != CREATING) {
        throw new ActivationException("group not being created");
    }

    group = inst;
    status = NORMAL;
    notifyAll();
}
 

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
synchronized void registerObject(ActivationID id,
                                 ActivationDesc desc,
                                 boolean addRecord)
    throws UnknownGroupException, ActivationException
{
    checkRemoved();
    objects.put(id, new ObjectEntry(desc));
    if (desc.getRestartMode() == true) {
        restartSet.add(id);
    }

    // table insertion must take place before log update
    idTable.put(id, groupID);

    if (addRecord) {
        addLogRecord(new LogRegisterObject(id, desc));
    }
}
 

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
synchronized void unregisterObject(ActivationID id, boolean addRecord)
    throws UnknownGroupException, ActivationException
{
    ObjectEntry objEntry = getObjectEntry(id);
    objEntry.removed = true;
    objects.remove(id);
    if (objEntry.desc.getRestartMode() == true) {
        restartSet.remove(id);
    }

    // table removal must take place before log update
    idTable.remove(id);
    if (addRecord) {
        addLogRecord(new LogUnregisterObject(id));
    }
}
 

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
synchronized void unregisterGroup(boolean addRecord)
   throws UnknownGroupException, ActivationException
{
    checkRemoved();
    removed = true;
    for (Map.Entry<ActivationID,ObjectEntry> entry :
             objects.entrySet())
    {
        ActivationID id = entry.getKey();
        idTable.remove(id);
        ObjectEntry objEntry = entry.getValue();
        objEntry.removed = true;
    }
    objects.clear();
    restartSet.clear();
    reset();
    childGone();

    // removal should be recorded before log update
    if (addRecord) {
        addLogRecord(new LogUnregisterGroup(groupID));
    }
}
 

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
synchronized ActivationDesc setActivationDesc(ActivationID id,
                                              ActivationDesc desc,
                                              boolean addRecord)
    throws UnknownObjectException, UnknownGroupException,
           ActivationException
{
    ObjectEntry objEntry = getObjectEntry(id);
    ActivationDesc oldDesc = objEntry.desc;
    objEntry.desc = desc;
    if (desc.getRestartMode() == true) {
        restartSet.add(id);
    } else {
        restartSet.remove(id);
    }
    // restart information should be recorded before log update
    if (addRecord) {
        addLogRecord(new LogUpdateDesc(id, desc));
    }

    return oldDesc;
}
 

import java.rmi.activation.UnknownGroupException; //导入依赖的package包/类
synchronized void inactiveGroup(long incarnation, boolean failure)
    throws UnknownGroupException
{
    checkRemoved();
    if (this.incarnation != incarnation) {
        throw new UnknownGroupException("invalid incarnation");
    }

    reset();
    if (failure) {
        terminate();
    } else if (child != null && status == NORMAL) {
        status = TERMINATE;
        watchdog.noRestart();
    }
}