Examples with IntArray com.cosylab.acs.maci.IntArray used on opensource projects

Example 6 with IntArray

use of com.cosylab.acs.maci.IntArray in project ACS by ACS-Community.

the class ManagerImpl method internalNoSyncRequestComponentPhase2.

private ComponentInfo internalNoSyncRequestComponentPhase2(int requestor, String name, String type, String code, String containerName, int keepAliveTime, StatusHolder status, AcsJCannotGetComponentEx bcex, boolean isOtherDomainComponent, boolean isDynamicComponent, int h, boolean reactivate, ComponentInfo componentInfo, Container container, ContainerInfo containerInfo, long executionId, long activationTime, boolean timeoutError) throws AcsJCannotGetComponentEx {
    // remove component from client component list, will be added later (first lots of checks has to be done)
    if ((requestor & TYPE_MASK) == COMPONENT_MASK) {
        removeComponentOwner(h | COMPONENT_MASK, requestor);
    }
    // remove from pending activation list
    synchronized (pendingActivations) {
        pendingActivations.remove(name);
    }
    // failed to activate
    if (componentInfo == null || componentInfo.getHandle() == 0 || componentInfo.getComponent() == null) {
        if (bcex == null)
            logger.log(Level.SEVERE, "Failed to activate component '" + name + "' (" + HandleHelper.toString(h | COMPONENT_MASK) + ").");
        else
            bcex.setReason("Failed to activate component '" + name + "' (" + HandleHelper.toString(h | COMPONENT_MASK) + ").");
        componentsLock.lock();
        try {
            // !!! ACID 3
            if (!reactivate)
                executeCommand(new ComponentCommandDeallocate(h, h | COMPONENT_MASK, timeoutError ? WhyUnloadedReason.TIMEOUT : WhyUnloadedReason.REMOVED, true));
        //components.deallocate(h, true);
        } finally {
            componentsLock.unlock();
        }
        status.setStatus(ComponentStatus.COMPONENT_NOT_ACTIVATED);
        if (bcex == null)
            return null;
        else
            throw bcex;
    }
    // log info
    logger.log(Level.INFO, "Component '" + name + "' (" + HandleHelper.toString(h | COMPONENT_MASK) + ") activated successfully.");
    //
    if (!isOtherDomainComponent && !componentInfo.getComponent().doesImplement(type)) {
        // just output SEVERE message
        logger.log(Level.SEVERE, "Activated component '" + name + "' does not implement specified type '" + type + "'.");
    }
    // component info (to get type and code, container - prefix name)
    if (isOtherDomainComponent) {
        // @todo MF tmp (for testing)
        componentInfo.setHandle(h | COMPONENT_MASK);
        componentInfo.setClients(new IntArray());
        componentInfo.setComponents(new IntArray(0));
        componentInfo.setContainer(0);
        // set variables
        type = componentInfo.getType();
        code = componentInfo.getCode();
    }
    int[] clients;
    componentsLock.lock();
    try {
        //
        if (componentInfo.getHandle() != (h | COMPONENT_MASK)) {
            // container returned different handle
            // (it seems it has already activated this Component)
            // check if we can accept it
            int componentHandle = componentInfo.getHandle() & HANDLE_MASK;
            if (components.isAllocated(componentHandle)) {
                // cancel preallocation
                if (!reactivate)
                    executeCommand(new ComponentCommandDeallocate(h, componentInfo.getHandle(), WhyUnloadedReason.REMOVED, true));
                //components.deallocate(h, true);
                bcex = new AcsJCannotGetComponentEx();
                bcex.setReason("Container '" + containerName + "' returned another '" + name + "' component handle than given, failed to fix handle since returned handle is already allocated.");
                // log this anyway, since it's an error of a global nature
                logger.log(Level.SEVERE, "Container '" + containerName + "' returned another '" + name + "' component handle than given, failed to fix handle since returned handle is already allocated.", bcex);
                // component is activated, but cannot be managed by the Manager
                status.setStatus(ComponentStatus.COMPONENT_ACTIVATED);
                throw bcex;
            } else {
                // handle is free, relocate handle
                ComponentInfo existingData = null;
                // deallocate old
                if (!reactivate)
                    executeCommand(new ComponentCommandDeallocate(h, componentInfo.getHandle(), WhyUnloadedReason.REPLACED, true));
                else //components.deallocate(h, true);
                {
                    // !!! ACID 3
                    existingData = (ComponentInfo) components.get(h);
                    executeCommand(new ComponentCommandDeallocate(h, componentInfo.getHandle(), WhyUnloadedReason.REPLACED));
                //components.deallocate(h);
                }
                // !!! ACID 3
                // preallocate new
                Integer objHandle = (Integer) executeCommand(new ComponentCommandAllocateHandle(componentHandle, true));
                //h = components.allocate(componentHandle, true);
                if (objHandle == null || (h = objHandle.intValue()) == 0) {
                    // failed to allocate new
                    bcex = new AcsJCannotGetComponentEx();
                    bcex.setReason("Container '" + containerName + "' returned another '" + name + "' component handle than given, failed to fix handle due to handle relocation failure.");
                    // log this anyway, since it's an error of a global nature
                    logger.log(Level.SEVERE, "Container '" + containerName + "' returned another '" + name + "' component handle than given, failed to fix handle due to handle relocation failure.", bcex);
                    // Component is activated, but cannot be managed by the Manager
                    status.setStatus(ComponentStatus.COMPONENT_ACTIVATED);
                    throw bcex;
                } else // !!! ACID 3
                if (existingData != null)
                    executeCommand(new ComponentCommandSet(h, existingData));
                //components.set(h, existingData);
                logger.log(Level.WARNING, "Container '" + containerName + "' returned another '" + name + "' component handle than given, handle fixed.");
            }
        }
        //
        // pre-store data
        //
        ComponentInfo existingData = (ComponentInfo) components.get(h);
        // create a new ComponentInfo - do not trust containers
        ComponentInfo data = new ComponentInfo(componentInfo.getHandle(), name, type, code, componentInfo.getComponent());
        if (existingData != null) {
            data.setClients(existingData.getClients());
            data.setComponents(existingData.getComponents());
        }
        if (requestor != 0)
            if (// hierarchical components need this check
            !data.getClients().contains(requestor))
                data.getClients().add(requestor);
        if (keepAliveTime <= RELEASE_NEVER)
            if (// make component immortal
            !data.getClients().contains(this.getHandle()))
                data.getClients().add(this.getHandle());
        // remember keep alive time
        data.setKeepAliveTime(keepAliveTime);
        if (isOtherDomainComponent) {
            data.setContainer(0);
            data.setContainerName(componentInfo.getContainerName());
        } else {
            data.setContainer(containerInfo.getHandle());
            data.setContainerName(containerInfo.getName());
        }
        data.setAccessRights(0);
        data.setInterfaces(componentInfo.getInterfaces());
        // mark as dynamic component and store its container
        if (isDynamicComponent) {
            data.setDynamic(true);
            data.setDynamicContainerName(containerName);
        }
        // !!! ACID
        executeCommand(new ComponentCommandSet(h, data));
        // acknowledge allocation
        if (!reactivate)
            // !!! ACID 2
            executeCommand(new ComponentCommandAckAlloc(h));
        //components.ackAllocation(h);
        componentInfo = data;
        clients = componentInfo.getClients().toArray();
    } finally {
        componentsLock.unlock();
    }
    if (!isOtherDomainComponent) {
        // add component to client component list to allow dependency checks
        if ((requestor & TYPE_MASK) == COMPONENT_MASK)
            addComponentOwner(componentInfo.getHandle(), requestor);
        //
        // call construct
        //
        boolean constructed = false;
        try {
            componentInfo.getComponent().construct();
            constructed = true;
        } catch (Throwable ex) {
            bcex = new AcsJCannotGetComponentEx(ex);
            bcex.setReason("Failed to construct component '" + name + "', exception caught when invoking 'construct()' method.");
        }
        // remove component from client component list, will be added later
        if ((requestor & TYPE_MASK) == COMPONENT_MASK)
            removeComponentOwner(componentInfo.getHandle(), requestor);
        if (!constructed) {
            // release Component
            componentsLock.lock();
            try {
                // !!! ACID 3
                if (!reactivate)
                    executeCommand(new ComponentCommandDeallocate(h, componentInfo.getHandle(), WhyUnloadedReason.REMOVED));
                // deactivate
                try {
                    container.deactivate_component(componentInfo.getHandle());
                } catch (Exception ex) {
                    bcex = new AcsJCannotGetComponentEx(ex);
                    bcex.setReason("Failed to deactivate component '" + name + "' on container '" + containerName + "'.");
                }
                status.setStatus(ComponentStatus.COMPONENT_NOT_ACTIVATED);
                throw bcex;
            } finally {
                componentsLock.unlock();
            }
        }
    }
    // add component to client component list
    if (requestor != this.getHandle() && requestor != 0)
        addComponentOwner(componentInfo.getHandle(), requestor);
    // add component to container component list
    if (!isOtherDomainComponent)
        synchronized (containerInfo.getComponents()) {
            if (!containerInfo.getComponents().contains(componentInfo.getHandle()))
                executeCommand(new ContainerInfoCommandComponentAdd(containerInfo.getHandle() & HANDLE_MASK, componentInfo.getHandle()));
        //containerInfo.getComponents().add(componentInfo.getHandle());
        }
    // remove component from unavailable list
    if (reactivate) {
        synchronized (unavailableComponents) {
            executeCommand(new UnavailableComponentCommandRemove(name));
        //unavailableComponents.remove(name);
        }
    }
    //
    if (!isOtherDomainComponent)
        notifyComponentActivated(componentInfo, activationTime, executionId);
    //
    if (reactivate) {
        notifyComponentAvailable(requestor, clients, new ComponentInfo[] { componentInfo });
    }
    //
    // notify administrators about the activation
    //
    notifyComponentRequested(new int[] { requestor }, new int[] { componentInfo.getHandle() }, activationTime);
    if (reactivate)
        logger.log(Level.FINE, "Component '" + name + "' (" + HandleHelper.toString(componentInfo.getHandle()) + ") reactivated.");
    else
        logger.log(Level.FINE, "Component '" + name + "' (" + HandleHelper.toString(componentInfo.getHandle()) + ") activated.");
    // notify about the change (only this-domain container which activated the component)...
    if (containerInfo != null)
        topologySortManager.notifyTopologyChange(containerInfo.getHandle());
    status.setStatus(ComponentStatus.COMPONENT_ACTIVATED);
    return componentInfo;
}

Example 7 with IntArray

use of com.cosylab.acs.maci.IntArray in project ACS by ACS-Community.

the class ManagerImpl method containerInternalStateMerge.

/**
	 * Retrieve container's internal state and merge it with manager's.
	 * NOTE: this method should not be run in separate thread since states
	 * should be merged synchronously.
	 * Merge is split to two parts:
	 *
	 * <h2>Container -> Manager</h2>
	 *
	 * If container component handle is also allocated in manager state and components information match,
	 * then we have a perfect fit and no action is required. If they do not match, container is rejected.
	 * If container component handle is not allocated in the manager state and no component with
	 * same name is found in manager state, component information is transferred to the manager,
	 * owtherwise container is rejected.
	 * <p>
	 * NOTE: The second option allows components without owners to be activated.
	 * </p>
	 * <p>
	 * NOTE: Container is rejected due to its state inconsistency which will probably cause
	 * problems in the future. Container has to be restarted.<br/>
	 * (A more sophisticated algorithm could give manager "the power to shape up" container state.)
	 * </p>
	 * <p>
	 * NOTE: Container -> Manager has to work in the way transactions do, i.e. in case of rejection
	 * manager state should no be affected.
	 * </p>
	 *
	 * <h2>Manager -> Container</h2>
	 *
	 * If <code>recoverContainer</code> is <code>true</code>, all components known to the manager to
	 * be activated on this particular container and listed as activated by the container
	 * will be marked as unavailable to be reactivated later by
	 * <code>containerPostLoginActivation</code> method.
	 * If <code>recoverContainer</code> is <code>false</code>, all there information will be discared
	 * (components removed from container component list, deallocated, and removed from their owners list).
	 *
	 * @param	containerInfo	container info for which to perform merge, non-<code>null</code>.
	 * @param	recoverContainer	if <code>true</code> manager state will be 'transferred' to container.
	 */
private void containerInternalStateMerge(ContainerInfo containerInfo, boolean recoverContainer) throws AcsJNoPermissionEx {
    assert (containerInfo != null);
    // firstly, query containers state
    ComponentInfo[] infos = null;
    try {
        infos = containerInfo.getContainer().get_component_info(new int[0]);
    } catch (Throwable ex) {
        logger.log(Level.SEVERE, "Failed to query state of container '" + containerInfo.getName() + "'.", ex);
    }
    boolean requireTopologySort = false;
    // copy elements
    IntArray managerContainersComponents;
    synchronized (containerInfo.getComponents()) {
        managerContainersComponents = new IntArray(containerInfo.getComponents().toArray());
    }
    if (infos != null && infos.length > 0) {
        componentsLock.lock();
        try {
            // phase 1: check for state consistency
            for (int i = 0; i < infos.length; i++) {
                // check if info is valid
                if (infos[i].getHandle() == 0 || (infos[i].getHandle() & COMPONENT_MASK) != COMPONENT_MASK || infos[i].getName() == null || infos[i].getType() == null || infos[i].getCode() == null || infos[i].getComponent() == null || infos[i].getContainer() == 0 || infos[i].getInterfaces() == null) {
                    // bad info
                    // NO_PERMISSION
                    AcsJNoPermissionEx npe = new AcsJNoPermissionEx();
                    npe.setReason("Inconsistent container state - component information is not valid, rejecting container.");
                    npe.setID(containerInfo.getName());
                    npe.setProtectedResource(infos[i].getName());
                    throw npe;
                }
                int handle = infos[i].getHandle() & HANDLE_MASK;
                if (components.isAllocated(handle)) {
                    // handle is allocated
                    // check if components information match
                    ComponentInfo componentInfo = (ComponentInfo) components.get(handle);
                    if (componentInfo == null || componentInfo.getHandle() != infos[i].getHandle() || !componentInfo.getName().equals(infos[i].getName()) || (componentInfo.getContainer() != 0 && componentInfo.getContainer() != infos[i].getContainer())) {
                        // information does not match, reject container
                        // NO_PERMISSION
                        AcsJNoPermissionEx npe = new AcsJNoPermissionEx();
                        npe.setReason("Inconsistent container state - components information do not match, rejecting container.");
                        npe.setID(containerInfo.getName());
                        if (componentInfo != null) {
                            npe.setProtectedResource(componentInfo.getName());
                        }
                        throw npe;
                    }
                } else {
                    // handle is not allocated
                    // check if component with same name is already registered
                    int h = components.first();
                    while (h != 0) {
                        ComponentInfo componentInfo = (ComponentInfo) components.get(h);
                        if (componentInfo.getName().equals(infos[i].getName())) {
                            // yes it does, reject container
                            // NO_PERMISSION
                            AcsJNoPermissionEx npe = new AcsJNoPermissionEx();
                            npe.setReason("Inconsistent container state - component with name '" + componentInfo.getName() + "' already registered with different handle, rejecting container.");
                            npe.setID(containerInfo.getName());
                            npe.setProtectedResource(componentInfo.getName());
                            throw npe;
                        }
                        h = components.next(h);
                    }
                }
            }
            // phase 2: do the transfer
            for (int i = 0; i < infos.length; i++) {
                int handle = infos[i].getHandle() & HANDLE_MASK;
                if (components.isAllocated(handle)) {
                    // handle is allocated and info match
                    // just in case component is not persistent, update the reference
                    // is always non-null - checked already above
                    ComponentInfo componentInfo = (ComponentInfo) components.get(handle);
                    componentInfo.setComponent(infos[i].getComponent());
                    componentInfo.setContainer(infos[i].getContainer());
                    componentInfo.setContainerName(infos[i].getContainerName());
                    // remove if unavailable and notify
                    synchronized (unavailableComponents) {
                        // !!! ACID 3
                        executeCommand(new UnavailableComponentCommandRemove(componentInfo.getName()));
                    //unavailableComponents.remove(componentInfo.getName());
                    }
                    int[] clients = componentInfo.getClients().toArray();
                    notifyComponentAvailable(0, clients, new ComponentInfo[] { componentInfo });
                } else {
                    // handle is not allocated
                    // transfer component
                    // create new ComponentInfo (we do not trust containers)
                    ComponentInfo info = new ComponentInfo(infos[i].getHandle(), infos[i].getName(), infos[i].getType(), infos[i].getCode(), infos[i].getComponent());
                    info.setContainer(infos[i].getContainer());
                    info.setContainerName(infos[i].getContainerName());
                    info.setInterfaces(infos[i].getInterfaces());
                    info.setAccessRights(0);
                    // if it has a CDB entry or if there is no CDB available
                    if (!hasCDBEntry(info)) {
                        info.setDynamic(true);
                        info.setDynamicContainerName(containerInfo.getName());
                    }
                    // !!! ACID 3
                    // allocate and store
                    executeCommand(new ComponentCommandAllocateHandle(handle));
                    //components.allocate(handle);
                    executeCommand(new ComponentCommandSet(handle, info));
                    //components.set(handle, info);
                    requireTopologySort = true;
                }
                // we handled this component
                managerContainersComponents.remove(infos[i].getHandle());
                // add to container component list
                synchronized (containerInfo.getComponents()) {
                    // !!! ACID 3
                    if (!containerInfo.getComponents().contains(infos[i].getHandle()))
                        executeCommand(new ContainerInfoCommandComponentAdd(containerInfo.getHandle() & HANDLE_MASK, infos[i].getHandle()));
                //containerInfo.getComponents().add(infos[i].getHandle());
                }
            }
        } finally {
            componentsLock.unlock();
        }
    }
    // managerContainersComponents contains component handles not handled yet
    for (int i = 0; i < managerContainersComponents.size(); i++) {
        int componentHandle = managerContainersComponents.get(i);
        // remove component handle from container component list
        // will be added when actually activated
        // !!! ACID 3
        executeCommand(new ContainerInfoCommandComponentRemove(containerInfo.getHandle() & HANDLE_MASK, componentHandle));
        //containerInfo.getComponents().remove(componentHandle);
        // marked as unavailable to be reactivated later (or discarded)
        componentsLock.lock();
        try {
            int handle = componentHandle & HANDLE_MASK;
            if (components.isAllocated(handle)) {
                ComponentInfo componentInfo = (ComponentInfo) components.get(handle);
                // what if null (very not likely to happen, but possible)
                if (componentInfo == null) {
                    // internal error, this should not happen
                    logger.log(Level.SEVERE, "Internal state is not consistent (no ComponentInfo).");
                    continue;
                }
                // notify component owners about Component deactivation
                makeUnavailable(componentInfo);
                if (!recoverContainer) {
                    // discard all Component information
                    // remove from its owners list ...
                    int[] owners = componentInfo.getClients().toArray();
                    for (int j = 0; j < owners.length; j++) removeComponentOwner(componentHandle, owners[j]);
                    // !!! ACID 3
                    // ... and deallocate
                    executeCommand(new ComponentCommandDeallocate(handle, componentInfo.getHandle(), WhyUnloadedReason.REMOVED));
                    //components.deallocate(handle);
                    requireTopologySort = true;
                }
            } else {
                // internal error, this should not happen
                logger.log(Level.SEVERE, "Internal state is not consistent.");
            }
        } finally {
            componentsLock.unlock();
        }
    }
    if (requireTopologySort)
        topologySortManager.notifyTopologyChange(containerInfo.getHandle());
}

Example 8 with IntArray

use of com.cosylab.acs.maci.IntArray in project ACS by ACS-Community.

the class ComponentInfoTopologicalSortManager method run.

/**
	 * (Sync is clean since activationPendingRWLock is acquired and all
	 * notify request is issued only from its reader lock).
	 * @see java.lang.Runnable#run()
	 */
public void run() {
    while (!destroyed) {
        synchronized (this) {
            int dirtyContainersCount;
            synchronized (dirtyContainerMap) {
                dirtyContainersCount = dirtyContainerMap.size();
            }
            if (dirtyContainersCount == 0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    return;
                }
            }
        }
        if (destroyed)
            return;
        // aquire writer lock to prevent activation/deactivation
        activationPendingRWLock.writeLock().lock();
        try {
            Integer[] conts;
            synchronized (dirtyContainerMap) {
                conts = new Integer[dirtyContainerMap.size()];
                dirtyContainerMap.toArray(conts);
                dirtyContainerMap.clear();
            }
            ComponentInfo[] orderedList;
            synchronized (components) {
                List list = ComponentInfoTopologicalSort.sort(components);
                orderedList = new ComponentInfo[list.size()];
                list.toArray(orderedList);
            }
            synchronized (listLock) {
                currentTSList = orderedList;
            }
            for (int i = 0; i < conts.length; i++) {
                int handle = conts[i].intValue() & HandleConstants.HANDLE_MASK;
                ContainerInfo containerInfo = null;
                synchronized (containers) {
                    if (containers.isAllocated(handle))
                        containerInfo = (ContainerInfo) containers.get(handle);
                }
                if (containerInfo == null || containerInfo.getName() == null)
                    break;
                String containerName = containerInfo.getName();
                // check if shutdown state
                if (pendingContainerShutdown.contains(containerName))
                    break;
                IntArray containerOrderdList = new IntArray(10);
                for (int j = 0; j < orderedList.length; j++) {
                    // if component already deactivated, skip it
                    if (orderedList[j].getContainer() == 0)
                        continue;
                    // this is null proof
                    if (containerName.equals(orderedList[j].getContainerName())) {
                        containerOrderdList.add(orderedList[j].getHandle());
                    }
                }
                // optimization
                if (containerOrderdList.size() > 1)
                    notifyContainerShutdownOrder(containerInfo, containerOrderdList.toArray());
            }
        } finally {
            activationPendingRWLock.writeLock().unlock();
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException ex) {
            logger.log(Level.WARNING, "Exception caught while waiting in run() method");
            ex.printStackTrace();
        }
    }
}

Example 9 with IntArray

use of com.cosylab.acs.maci.IntArray in project ACS by ACS-Community.

the class ManagerImplTest method testForceReleaseComponent.

public void testForceReleaseComponent() {
    try {
        try {
            manager.forceReleaseComponent(0, null);
            fail();
        } catch (AcsJBadParameterEx bpe) {
            System.out.println("This is OK: null parameter");
        }
        try {
            manager.forceReleaseComponent(Integer.MAX_VALUE, null);
            fail();
        } catch (AcsJBadParameterEx bpe) {
            System.out.println("This is OK: null parameter");
        }
        try {
            manager.forceReleaseComponent(dummyHandle, dummyURI);
            fail();
        } catch (AcsJNoPermissionEx npe) {
            System.out.println("This is OK: " + npe.toString());
        } catch (AcsJBadParameterEx bpe) {
            fail();
        }
        TestAdministrator admin = new TestAdministrator(administratorName);
        ClientInfo adminInfo = manager.login(admin);
        assertTrue(adminInfo.getHandle() != 0);
        TestClient client = new TestClient(clientName);
        ClientInfo info = manager.login(client);
        assertTrue(info.getHandle() != 0);
        TestClient client2 = new TestClient(clientName + "2");
        ClientInfo info2 = manager.login(client2);
        assertTrue(info2.getHandle() != 0);
        TestContainer container = new TestContainer("Container");
        Map supportedComponents = new HashMap();
        Component mount1COB = new TestComponent("MOUNT1");
        Component mount4COB = new TestComponent("MOUNT4");
        supportedComponents.put("MOUNT1", mount1COB);
        supportedComponents.put("MOUNT4", mount4COB);
        container.setSupportedComponents(supportedComponents);
        ClientInfo containerInfo = manager.login(container);
        // client activate 
        URI mount4 = null;
        try {
            mount4 = new URI("MOUNT4");
            StatusHolder status = new StatusHolder();
            Component ref = manager.getComponent(info.getHandle(), mount4, true, status);
            assertEquals(mount4COB, ref);
            assertEquals(ComponentStatus.COMPONENT_ACTIVATED, status.getStatus());
        } catch (Exception ex) {
            fail();
        }
        // client2 activate 
        try {
            StatusHolder status = new StatusHolder();
            Component ref = manager.getComponent(info2.getHandle(), mount4, true, status);
            assertEquals(mount4COB, ref);
            assertEquals(ComponentStatus.COMPONENT_ACTIVATED, status.getStatus());
        } catch (Exception ex) {
            fail();
        }
        try {
            Thread.sleep(STARTUP_COBS_SLEEP_TIME_MS);
        } catch (InterruptedException ie) {
        }
        // test activated Components
        // there should be only two Components activated (MOUNT1 and MOUNT4)
        ComponentInfo[] infos = manager.getComponentInfo(info.getHandle(), new int[0], "*", "*", true);
        assertEquals(2, infos.length);
        /*
			// test forceful release (no permission - no admin)
			try
			{
				manager.forceReleaseComponent(info.getHandle(), mount4);
				fail();
			}
			catch (AcsJNoPermissionEx npe)
			{
	
				System.out.println("This is OK: "+npe.toString());
			}
			*/
        // TODO tmp - due to Heiko's hack
        System.out.println("This is OK: Insufficient rights.");
        // test forceful release
        int clients;
        try {
            clients = manager.forceReleaseComponent(adminInfo.getHandle(), mount4);
            assertEquals(2, clients);
        } catch (AcsJBadParameterEx e) {
            fail();
        }
        // there should be only one component activated (MOUNT1)
        infos = manager.getComponentInfo(info.getHandle(), new int[0], "*", "*", true);
        assertEquals(1, infos.length);
        // admin activate 
        try {
            StatusHolder status = new StatusHolder();
            Component ref = manager.getComponent(adminInfo.getHandle(), mount4, true, status);
            assertEquals(mount4COB, ref);
            assertEquals(ComponentStatus.COMPONENT_ACTIVATED, status.getStatus());
        } catch (Exception ex) {
            fail();
        }
        // there should be two components activated (MOUNT1 and MOUNT4)
        infos = manager.getComponentInfo(info.getHandle(), new int[0], "*", "*", true);
        assertEquals(2, infos.length);
        try {
            clients = manager.releaseComponent(adminInfo.getHandle(), mount4);
            assertEquals(2, clients);
        } catch (AcsJBadParameterEx e) {
            fail();
        }
        // there should be two components activated (MOUNT1 and MOUNT4)
        infos = manager.getComponentInfo(info.getHandle(), new int[0], "*", "*", true);
        assertEquals(2, infos.length);
        // there should be two components activated (MOUNT1 and MOUNT4)
        infos = manager.getComponentInfo(info.getHandle(), new int[0], "MOUNT4", "*", true);
        assertEquals(1, infos.length);
        IntArray compClients = infos[0].getClients();
        assertEquals(2, compClients.size());
        assertTrue(compClients.contains(info.getHandle()));
        assertTrue(compClients.contains(info2.getHandle()));
    } catch (AcsJNoPermissionEx e) {
        fail("No permission");
    }
}

Example 10 with IntArray

use of com.cosylab.acs.maci.IntArray in project ACS by ACS-Community.

the class ManagerProxy method getComponentInfo.

/**
     * @see com.cosylab.acs.maci.Manager#getComponentInfo(int, int[], java.lang.String, java.lang.String, boolean)
     */
public ComponentInfo[] getComponentInfo(int id, int[] handles, String name_wc, String type_wc, boolean activeOnly) throws AcsJNoPermissionEx {
    try {
        // returned value
        ComponentInfo[] retVal = null;
        // transform to CORBA specific 
        si.ijs.maci.ComponentInfo[] infos = manager.get_component_info(id, handles, name_wc, type_wc, activeOnly);
        if (infos != null) {
            retVal = new ComponentInfo[infos.length];
            for (int i = 0; i < infos.length; i++) {
                ComponentInfo componentInfo = new ComponentInfo(infos[i].h, infos[i].name, infos[i].type, infos[i].code, new ComponentProxy(infos[i].name, infos[i].reference));
                componentInfo.setContainer(infos[i].container);
                componentInfo.setContainerName(infos[i].container_name);
                componentInfo.setAccessRights(ContainerProxy.inverseMapAccessRights(infos[i].access));
                componentInfo.setClients(new IntArray(infos[i].clients));
                componentInfo.setInterfaces(infos[i].interfaces);
                retVal[i] = componentInfo;
            }
        }
        return retVal;
    } catch (NoPermissionEx npex) {
        AcsJNoPermissionEx npe = new AcsJNoPermissionEx();
        npe.setReason("Remote manager has thrown no permission exception.");
        npe.setID(HandleHelper.toString(id));
        throw npe;
    } catch (Exception ex) {
        //throw re;
        return null;
    }
}