Examples with VisibleForTesting io.crate.common.annotations.VisibleForTesting used on opensource projects

Example 26 with VisibleForTesting

use of io.crate.common.annotations.VisibleForTesting in project crate by crate.

the class TransportPrivilegesAction method applyPrivileges.

@VisibleForTesting
static long applyPrivileges(Metadata.Builder mdBuilder, PrivilegesRequest request) {
    // create a new instance of the metadata, to guarantee the cluster changed action.
    UsersPrivilegesMetadata newMetadata = UsersPrivilegesMetadata.copyOf((UsersPrivilegesMetadata) mdBuilder.getCustom(UsersPrivilegesMetadata.TYPE));
    long affectedRows = newMetadata.applyPrivileges(request.userNames(), request.privileges());
    mdBuilder.putCustom(UsersPrivilegesMetadata.TYPE, newMetadata);
    return affectedRows;
}

Example 27 with VisibleForTesting

use of io.crate.common.annotations.VisibleForTesting in project crate by crate.

the class TransportPrivilegesAction method validateUserNames.

@VisibleForTesting
static List<String> validateUserNames(Metadata metadata, Collection<String> userNames) {
    UsersMetadata usersMetadata = metadata.custom(UsersMetadata.TYPE);
    if (usersMetadata == null) {
        return new ArrayList<>(userNames);
    }
    List<String> unknownUserNames = null;
    for (String userName : userNames) {
        // noinspection PointlessBooleanExpression
        if (usersMetadata.userNames().contains(userName) == false) {
            if (unknownUserNames == null) {
                unknownUserNames = new ArrayList<>();
            }
            unknownUserNames.add(userName);
        }
    }
    if (unknownUserNames == null) {
        return Collections.emptyList();
    }
    return unknownUserNames;
}

Example 28 with VisibleForTesting

use of io.crate.common.annotations.VisibleForTesting in project crate by crate.

the class TransportAlterUserAction method alterUser.

@VisibleForTesting
static boolean alterUser(Metadata.Builder mdBuilder, String userName, @Nullable SecureHash secureHash) {
    UsersMetadata oldMetadata = (UsersMetadata) mdBuilder.getCustom(UsersMetadata.TYPE);
    if (oldMetadata == null || !oldMetadata.contains(userName)) {
        return false;
    }
    // create a new instance of the metadata, to guarantee the cluster changed action.
    UsersMetadata newMetadata = UsersMetadata.newInstance(oldMetadata);
    newMetadata.put(userName, secureHash);
    assert !newMetadata.equals(oldMetadata) : "must not be equal to guarantee the cluster change action";
    mdBuilder.putCustom(UsersMetadata.TYPE, newMetadata);
    return true;
}

Example 29 with VisibleForTesting

use of io.crate.common.annotations.VisibleForTesting in project crate by crate.

the class CreateAnalyzerPlan method createRequest.

@VisibleForTesting
public static ClusterUpdateSettingsRequest createRequest(AnalyzedCreateAnalyzer createAnalyzer, CoordinatorTxnCtx txnCtx, NodeContext nodeCtx, Row parameters, SubQueryResults subQueryResults, FulltextAnalyzerResolver ftResolver) {
    Function<? super Symbol, Object> eval = x -> SymbolEvaluator.evaluate(txnCtx, nodeCtx, x, parameters, subQueryResults);
    var analyzerIdent = createAnalyzer.ident();
    var tokenizer = bindTokenizer(createAnalyzer.tokenizer(), analyzerIdent, eval, ftResolver);
    var tokenFilters = bindTokenFilters(createAnalyzer.tokenFilters(), analyzerIdent, eval, ftResolver);
    var charFilters = bindCharFilters(createAnalyzer.charFilters(), analyzerIdent, eval, ftResolver);
    var genericAnalyzerSettings = bindGenericAnalyzerProperties(createAnalyzer.genericAnalyzerProperties(), analyzerIdent, eval);
    var analyzerSettings = buildAnalyzerSettings(analyzerIdent, createAnalyzer.extendedAnalyzerName(), tokenizer, tokenFilters, charFilters, genericAnalyzerSettings, ftResolver);
    Settings.Builder encodedSettingsBuilder = Settings.builder();
    encodedSettingsBuilder.put(ANALYZER.buildSettingName(analyzerIdent), encodeSettings(analyzerSettings).utf8ToString());
    if (tokenizer != null && !tokenizer.v2().isEmpty()) {
        encodedSettingsBuilder.put(TOKENIZER.buildSettingName(tokenizer.v1()), encodeSettings(tokenizer.v2()).utf8ToString());
    }
    for (Map.Entry<String, Settings> tokenFilter : tokenFilters.entrySet()) {
        if (!tokenFilter.getValue().isEmpty()) {
            encodedSettingsBuilder.put(TOKEN_FILTER.buildSettingName(tokenFilter.getKey()), encodeSettings(tokenFilter.getValue()).utf8ToString());
        }
    }
    for (Map.Entry<String, Settings> charFilter : charFilters.entrySet()) {
        if (!charFilter.getValue().isEmpty()) {
            encodedSettingsBuilder.put(CHAR_FILTER.buildSettingName(charFilter.getKey()), encodeSettings(charFilter.getValue()).utf8ToString());
        }
    }
    return new ClusterUpdateSettingsRequest().persistentSettings(encodedSettingsBuilder.build());
}

Example 30 with VisibleForTesting

use of io.crate.common.annotations.VisibleForTesting in project crate by crate.

the class CreateSnapshotPlan method createRequest.

@VisibleForTesting
public static CreateSnapshotRequest createRequest(AnalyzedCreateSnapshot createSnapshot, CoordinatorTxnCtx txnCtx, NodeContext nodeCtx, Row parameters, SubQueryResults subQueryResults, Schemas schemas) {
    Function<? super Symbol, Object> eval = x -> SymbolEvaluator.evaluate(txnCtx, nodeCtx, x, parameters, subQueryResults);
    Settings settings = GenericPropertiesConverter.genericPropertiesToSettings(createSnapshot.properties().map(eval), SnapshotSettings.SETTINGS);
    boolean ignoreUnavailable = IGNORE_UNAVAILABLE.get(settings);
    final HashSet<String> snapshotIndices;
    final HashSet<String> templates = new HashSet<>();
    if (createSnapshot.tables().isEmpty()) {
        for (SchemaInfo schemaInfo : schemas) {
            for (TableInfo tableInfo : schemaInfo.getTables()) {
                // only check for user generated tables
                if (tableInfo instanceof DocTableInfo) {
                    Operation.blockedRaiseException(tableInfo, Operation.READ);
                }
            }
        }
        snapshotIndices = new HashSet<>(AnalyzedCreateSnapshot.ALL_INDICES);
    } else {
        snapshotIndices = new HashSet<>(createSnapshot.tables().size());
        for (Table<Symbol> table : createSnapshot.tables()) {
            DocTableInfo docTableInfo;
            try {
                docTableInfo = (DocTableInfo) schemas.resolveTableInfo(table.getName(), Operation.CREATE_SNAPSHOT, txnCtx.sessionContext().sessionUser(), txnCtx.sessionContext().searchPath());
            } catch (Exception e) {
                if (ignoreUnavailable && e instanceof ResourceUnknownException) {
                    LOGGER.info("Ignore unknown relation '{}' for the '{}' snapshot'", table.getName(), createSnapshot.snapshot());
                    continue;
                } else {
                    throw e;
                }
            }
            if (docTableInfo.isPartitioned()) {
                templates.add(PartitionName.templateName(docTableInfo.ident().schema(), docTableInfo.ident().name()));
            }
            if (table.partitionProperties().isEmpty()) {
                snapshotIndices.addAll(Arrays.asList(docTableInfo.concreteIndices()));
            } else {
                var partitionName = toPartitionName(docTableInfo, Lists2.map(table.partitionProperties(), x -> x.map(eval)));
                if (!docTableInfo.partitions().contains(partitionName)) {
                    if (!ignoreUnavailable) {
                        throw new PartitionUnknownException(partitionName);
                    } else {
                        LOGGER.info("ignoring unknown partition of table '{}' with ident '{}'", partitionName.relationName(), partitionName.ident());
                    }
                } else {
                    snapshotIndices.add(partitionName.asIndexName());
                }
            }
        }
    }
    return new CreateSnapshotRequest(createSnapshot.snapshot().getRepository(), createSnapshot.snapshot().getSnapshotId().getName()).includeGlobalState(createSnapshot.tables().isEmpty()).waitForCompletion(WAIT_FOR_COMPLETION.get(settings)).indices(snapshotIndices.toArray(new String[0])).indicesOptions(IndicesOptions.fromOptions(ignoreUnavailable, true, true, false, IndicesOptions.lenientExpandOpen())).templates(templates.stream().toList()).settings(settings);
}