Examples with Holder com.evolveum.midpoint.util.Holder used on opensource projects

Example 6 with Holder

use of com.evolveum.midpoint.util.Holder in project midpoint by Evolveum.

the class ShadowCache method countObjects.

public Integer countObjects(ObjectQuery query, Task task, final OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    ResourceShadowDiscriminator coordinates = ObjectQueryUtil.getCoordinates(query.getFilter());
    final ProvisioningContext ctx = ctxFactory.create(coordinates, null, result);
    ctx.assertDefinition();
    applyDefinition(ctx, query);
    RefinedObjectClassDefinition objectClassDef = ctx.getObjectClassDefinition();
    ResourceType resourceType = ctx.getResource();
    CountObjectsCapabilityType countObjectsCapabilityType = objectClassDef.getEffectiveCapability(CountObjectsCapabilityType.class);
    if (countObjectsCapabilityType == null) {
        // Unable to count. Return null which means "I do not know"
        result.recordNotApplicableIfUnknown();
        return null;
    } else {
        CountObjectsSimulateType simulate = countObjectsCapabilityType.getSimulate();
        if (simulate == null) {
            // We have native capability
            ConnectorInstance connector = ctx.getConnector(ReadCapabilityType.class, result);
            try {
                ObjectQuery attributeQuery = createAttributeQuery(query);
                int count;
                try {
                    count = connector.count(objectClassDef.getObjectClassDefinition(), attributeQuery, objectClassDef.getPagedSearches(), ctx, result);
                } catch (CommunicationException | GenericFrameworkException | SchemaException | UnsupportedOperationException e) {
                    result.recordFatalError(e);
                    throw e;
                }
                result.computeStatus();
                result.cleanupResult();
                return count;
            } catch (GenericFrameworkException | UnsupportedOperationException e) {
                SystemException ex = new SystemException("Couldn't count objects on resource " + resourceType + ": " + e.getMessage(), e);
                result.recordFatalError(ex);
                throw ex;
            }
        } else if (simulate == CountObjectsSimulateType.PAGED_SEARCH_ESTIMATE) {
            if (!objectClassDef.isPagedSearchEnabled()) {
                throw new ConfigurationException("Configured count object capability to be simulated using a paged search but paged search capability is not present");
            }
            final Holder<Integer> countHolder = new Holder<Integer>(0);
            final ShadowHandler<ShadowType> handler = new ShadowHandler<ShadowType>() {

                @Override
                public boolean handle(ShadowType object) {
                    int count = countHolder.getValue();
                    count++;
                    countHolder.setValue(count);
                    return true;
                }
            };
            query = query.clone();
            ObjectPaging paging = ObjectPaging.createEmptyPaging();
            paging.setMaxSize(1);
            query.setPaging(paging);
            Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(new ItemPath(ShadowType.F_ASSOCIATION), GetOperationOptions.createRetrieve(RetrieveOption.EXCLUDE));
            SearchResultMetadata resultMetadata;
            try {
                resultMetadata = searchObjectsIterative(query, options, handler, false, task, result);
            } catch (SchemaException | ObjectNotFoundException | ConfigurationException | SecurityViolationException e) {
                result.recordFatalError(e);
                throw e;
            }
            result.computeStatus();
            result.cleanupResult();
            return resultMetadata.getApproxNumberOfAllResults();
        } else if (simulate == CountObjectsSimulateType.SEQUENTIAL_SEARCH) {
            // traditional way of counting objects (i.e. counting them one
            // by one)
            final Holder<Integer> countHolder = new Holder<Integer>(0);
            final ShadowHandler<ShadowType> handler = new ShadowHandler<ShadowType>() {

                @Override
                public boolean handle(ShadowType object) {
                    int count = countHolder.getValue();
                    count++;
                    countHolder.setValue(count);
                    return true;
                }
            };
            Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(new ItemPath(ShadowType.F_ASSOCIATION), GetOperationOptions.createRetrieve(RetrieveOption.EXCLUDE));
            searchObjectsIterative(query, options, handler, false, task, result);
            // TODO: better error handling
            result.computeStatus();
            result.cleanupResult();
            return countHolder.getValue();
        } else {
            throw new IllegalArgumentException("Unknown count capability simulate type " + simulate);
        }
    }
}

Example 7 with Holder

use of com.evolveum.midpoint.util.Holder in project midpoint by Evolveum.

the class OrgClosureManager method autoUpdateClosureTableStructure.

// TEMPORARY and quite BRUTAL HACK
// Originally in midPoint 3.0, m_org_closure has 5 columns, a non-null ID among them.
// In 3.1, it has 3, and no ID. Unfortunately, hibernate's hbm2ddl tool does not automatically remove ID column,
// so people can expect quite hard-to-understand error messages when running midPoint after upgrade.
//
// This code removes and re-creates the m_org_closure table if hbm2ddl is set to "update".
//
// returns true if the table was re-created
private boolean autoUpdateClosureTableStructure() {
    if (baseHelper.getConfiguration().isSkipOrgClosureStructureCheck()) {
        LOGGER.debug("Skipping org closure structure check.");
        return false;
    }
    SessionFactory sf = baseHelper.getSessionFactory();
    if (sf instanceof SessionFactoryImpl) {
        SessionFactoryImpl sfi = ((SessionFactoryImpl) sf);
        LOGGER.debug("SessionFactoryImpl.getSettings() = {}; auto update schema = {}", sfi.getSettings(), sfi.getSettings() != null ? sfi.getSettings().isAutoUpdateSchema() : null);
        if (sfi.getSettings() != null && sfi.getSettings().isAutoUpdateSchema()) {
            LOGGER.info("Checking the closure table structure.");
            final Session session = baseHelper.getSessionFactory().openSession();
            final Holder<Boolean> wrongNumberOfColumns = new Holder<>(false);
            session.doWork(new Work() {

                @Override
                public void execute(Connection connection) throws SQLException {
                    DatabaseMetaData meta = connection.getMetaData();
                    if (meta == null) {
                        LOGGER.warn("No database metadata found.");
                    } else {
                        ResultSet rsColumns = meta.getColumns(null, null, CLOSURE_TABLE_NAME, null);
                        int columns = 0;
                        while (rsColumns.next()) {
                            LOGGER.debug("Column: {} {}", rsColumns.getString("TYPE_NAME"), rsColumns.getString("COLUMN_NAME"));
                            columns++;
                        }
                        if (columns > 0) {
                            LOGGER.debug("There are {} columns in {} (obtained via DatabaseMetaData)", columns, CLOSURE_TABLE_NAME);
                            if (columns != 3) {
                                wrongNumberOfColumns.setValue(true);
                            }
                            return;
                        }
                        // perhaps some problem here... let's try another way out
                        try {
                            Statement stmt = connection.createStatement();
                            ResultSet rs = stmt.executeQuery("select * from " + CLOSURE_TABLE_NAME);
                            int cols = rs.getMetaData().getColumnCount();
                            if (cols > 0) {
                                LOGGER.debug("There are {} columns in {} (obtained via resultSet.getMetaData())", cols, CLOSURE_TABLE_NAME);
                                if (cols != 3) {
                                    wrongNumberOfColumns.setValue(true);
                                }
                            } else {
                                LOGGER.warn("Couldn't determine the number of columns in {}. In case of problems, please fix your database structure manually using DB scripts in 'config' folder.", CLOSURE_TABLE_NAME);
                            }
                            // don't care about closing them in case of failure
                            rs.close();
                            stmt.close();
                        } catch (RuntimeException e) {
                            LoggingUtils.logException(LOGGER, "Couldn't obtain the number of columns in {}. In case of problems running midPoint, please fix your database structure manually using DB scripts in 'config' folder.", e, CLOSURE_TABLE_NAME);
                        }
                    }
                }
            });
            if (wrongNumberOfColumns.getValue()) {
                session.getTransaction().begin();
                LOGGER.info("Wrong number of columns detected; dropping table " + CLOSURE_TABLE_NAME);
                Query q = session.createSQLQuery("drop table " + CLOSURE_TABLE_NAME);
                q.executeUpdate();
                session.getTransaction().commit();
                LOGGER.info("Calling hibernate hbm2ddl SchemaUpdate tool to create the table in the necessary form.");
                new SchemaUpdate(sfi.getServiceRegistry(), baseHelper.getSessionFactoryBean().getConfiguration()).execute(false, true);
                LOGGER.info("Done, table was (hopefully) created. If not, please fix your database structure manually using DB scripts in 'config' folder.");
                return true;
            }
        } else {
        // auto schema update is disabled
        }
    } else {
        LOGGER.warn("SessionFactory is not of type SessionFactoryImpl; it is {}", sf != null ? sf.getClass() : "null");
    }
    return false;
}

Example 8 with Holder

use of com.evolveum.midpoint.util.Holder in project midpoint by Evolveum.

the class TestDummy method test110SeachIterative.

@Test
public void test110SeachIterative() throws Exception {
    final String TEST_NAME = "test110SeachIterative";
    TestUtil.displayTestTile(TEST_NAME);
    // GIVEN
    OperationResult result = new OperationResult(TestDummy.class.getName() + "." + TEST_NAME);
    // Make sure there is an account on resource that the provisioning has
    // never seen before, so there is no shadow
    // for it yet.
    DummyAccount newAccount = new DummyAccount("meathook");
    newAccount.addAttributeValues(DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_FULLNAME_NAME, "Meathook");
    newAccount.addAttributeValues(DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_SHIP_NAME, "Sea Monkey");
    newAccount.addAttributeValues(DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_WEAPON_NAME, "hook");
    newAccount.addAttributeValue(DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_LOOT_NAME, 666L);
    newAccount.setEnabled(true);
    newAccount.setPassword("parrotMonster");
    dummyResource.addAccount(newAccount);
    ObjectQuery query = ObjectQueryUtil.createResourceAndObjectClassQuery(RESOURCE_DUMMY_OID, new QName(ResourceTypeUtil.getResourceNamespace(resourceType), SchemaConstants.ACCOUNT_OBJECT_CLASS_LOCAL_NAME), prismContext);
    final XMLGregorianCalendar startTs = clock.currentTimeXMLGregorianCalendar();
    final Holder<Boolean> seenMeathookHolder = new Holder<Boolean>(false);
    final List<PrismObject<ShadowType>> foundObjects = new ArrayList<PrismObject<ShadowType>>();
    ResultHandler<ShadowType> handler = new ResultHandler<ShadowType>() {

        @Override
        public boolean handle(PrismObject<ShadowType> object, OperationResult parentResult) {
            foundObjects.add(object);
            display("Found", object);
            XMLGregorianCalendar endTs = clock.currentTimeXMLGregorianCalendar();
            assertTrue(object.canRepresent(ShadowType.class));
            try {
                checkAccountShadow(object, parentResult, true, startTs, endTs);
            } catch (SchemaException e) {
                throw new SystemException(e.getMessage(), e);
            }
            assertCachingMetadata(object, false, startTs, endTs);
            if (object.asObjectable().getName().getOrig().equals("meathook")) {
                meathookAccountOid = object.getOid();
                seenMeathookHolder.setValue(true);
                try {
                    Long loot = ShadowUtil.getAttributeValue(object, dummyResourceCtl.getAttributeQName(DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_LOOT_NAME));
                    assertEquals("Wrong meathook's loot", (Long) 666L, loot);
                } catch (SchemaException e) {
                    throw new SystemException(e.getMessage(), e);
                }
            }
            return true;
        }
    };
    rememberShadowFetchOperationCount();
    // WHEN
    provisioningService.searchObjectsIterative(ShadowType.class, query, null, handler, null, result);
    // THEN
    XMLGregorianCalendar endTs = clock.currentTimeXMLGregorianCalendar();
    result.computeStatus();
    display("searchObjectsIterative result", result);
    TestUtil.assertSuccess(result);
    assertShadowFetchOperationCountIncrement(1);
    assertEquals(4, foundObjects.size());
    checkConsistency(foundObjects);
    assertProtected(foundObjects, 1);
    PrismObject<ShadowType> shadowWillRepo = repositoryService.getObject(ShadowType.class, ACCOUNT_WILL_OID, null, result);
    assertRepoShadowCachedAttributeValue(shadowWillRepo, DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_SHIP_NAME, "Flying Dutchman");
    checkRepoAccountShadowWill(shadowWillRepo, startTs, endTs);
    PrismObject<ShadowType> shadowMeathook = repositoryService.getObject(ShadowType.class, meathookAccountOid, null, result);
    display("Meathook shadow", shadowMeathook);
    assertRepoShadowCachedAttributeValue(shadowMeathook, DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_WEAPON_NAME, "hook");
    assertRepoCachingMetadata(shadowMeathook, startTs, endTs);
    // And again ...
    foundObjects.clear();
    rememberShadowFetchOperationCount();
    XMLGregorianCalendar startTs2 = clock.currentTimeXMLGregorianCalendar();
    // WHEN
    provisioningService.searchObjectsIterative(ShadowType.class, query, null, handler, null, result);
    // THEN
    XMLGregorianCalendar endTs2 = clock.currentTimeXMLGregorianCalendar();
    assertShadowFetchOperationCountIncrement(1);
    display("Found shadows", foundObjects);
    assertEquals(4, foundObjects.size());
    checkConsistency(foundObjects);
    assertProtected(foundObjects, 1);
    shadowWillRepo = repositoryService.getObject(ShadowType.class, ACCOUNT_WILL_OID, null, result);
    checkRepoAccountShadowWill(shadowWillRepo, startTs2, endTs2);
    shadowMeathook = repositoryService.getObject(ShadowType.class, meathookAccountOid, null, result);
    assertRepoShadowCachedAttributeValue(shadowMeathook, DummyResourceContoller.DUMMY_ACCOUNT_ATTRIBUTE_WEAPON_NAME, "hook");
    assertRepoCachingMetadata(shadowMeathook, startTs2, endTs2);
    assertSteadyResource();
}

Example 9 with Holder

use of com.evolveum.midpoint.util.Holder in project midpoint by Evolveum.

the class RemoteNodesManager method stopRemoteTaskRun.

// the task should be really running
void stopRemoteTaskRun(String oid, NodeType node, OperationResult parentResult) {
    OperationResult result = parentResult.createSubresult(RemoteNodesManager.class.getName() + ".stopRemoteTaskRun");
    result.addParam("oid", oid);
    result.addParam("node", node);
    LOGGER.debug("Interrupting task " + oid + " running at " + getClusterManager().dumpNodeInfo(node));
    String nodeName = node.getNodeIdentifier();
    String address = node.getHostname() + ":" + node.getJmxPort();
    Holder<JMXConnector> connectorHolder = new Holder<>();
    try {
        QuartzSchedulerMBean mbeanProxy = getSchedulerBean(node, connectorHolder, result);
        if (mbeanProxy != null) {
            try {
                mbeanProxy.interruptJob(oid, Scheduler.DEFAULT_GROUP);
                LOGGER.debug("Successfully signalled shutdown to task " + oid + " running at " + getClusterManager().dumpNodeInfo(node));
                result.recordSuccessIfUnknown();
            } catch (Exception e) {
                // necessary because of mbeanProxy
                String message = "Cannot signal task " + oid + " interruption to remote node " + nodeName + " at " + address;
                LoggingUtils.logUnexpectedException(LOGGER, message, e);
                result.recordFatalError(message + ":" + e.getMessage(), e);
            }
        }
    } finally {
        closeJmxConnection(connectorHolder, address);
    }
}

Example 10 with Holder

use of com.evolveum.midpoint.util.Holder in project midpoint by Evolveum.

the class InternalsCachePanel method getCacheInformation.

private String getCacheInformation() {
    StringBuilder sb = new StringBuilder();
    CachesStateInformationType state = MidPointApplication.get().getCacheRegistry().getStateInformation();
    List<KeyValueTreeNode<String, SizeInformation>> trees = new ArrayList<>();
    for (SingleCacheStateInformationType entry : state.getEntry()) {
        KeyValueTreeNode<String, SizeInformation> root = new KeyValueTreeNode<>(entry.getName(), new SizeInformation(entry));
        trees.add(root);
        addComponents(root, entry.getComponent());
    }
    Holder<Integer> maxLabelLength = new Holder<>(0);
    // to avoid issues with log10
    Holder<Integer> maxSize = new Holder<>(1);
    // to avoid issues with log10
    Holder<Integer> maxSecondarySize = new Holder<>(1);
    trees.forEach(tree -> tree.acceptDepthFirst(node -> {
        int labelLength = node.getUserObject().getKey().length() + node.getDepth() * 2;
        int size = node.getUserObject().getValue().size;
        int secondarySize = node.getUserObject().getValue().secondarySize;
        if (labelLength > maxLabelLength.getValue()) {
            maxLabelLength.setValue(labelLength);
        }
        if (size > maxSize.getValue()) {
            maxSize.setValue(size);
        }
        if (secondarySize > maxSecondarySize.getValue()) {
            maxSecondarySize.setValue(secondarySize);
        }
    }));
    int labelSize = Math.max(maxLabelLength.getValue() + 1, 30);
    int sizeSize = Math.max((int) Math.log10(maxSize.getValue()) + 2, 7);
    int secondarySizeSize = Math.max((int) Math.log10(maxSecondarySize.getValue()) + 2, 8);
    int firstPart = labelSize + 3;
    int secondPart = sizeSize + 2;
    int thirdPart = secondarySizeSize + 3;
    String headerFormatString = "  %-" + labelSize + "s | %" + sizeSize + "s | %" + secondarySizeSize + "s\n";
    String valueFormatString = "  %-" + labelSize + "s | %" + sizeSize + "d | %" + secondarySizeSize + "s\n";
    sb.append("\n");
    sb.append(String.format(headerFormatString, "Cache", "Size", "Sec. size"));
    sb.append(StringUtils.repeat("=", firstPart)).append("+").append(StringUtils.repeat("=", secondPart)).append("+").append(StringUtils.repeat("=", thirdPart)).append("\n");
    trees.forEach(tree -> {
        tree.acceptDepthFirst(node -> printNode(sb, valueFormatString, node));
        sb.append(StringUtils.repeat("-", firstPart)).append("+").append(StringUtils.repeat("-", secondPart)).append("+").append(StringUtils.repeat("-", thirdPart)).append("\n");
    });
    return sb.toString();
}