From 7c3a1f7b46d57abe7fc8a95639b6db224ee6157b Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 27 Oct 2021 19:06:14 +0530 Subject: [PATCH 01/15] Implementing graphql apis for label application rules --- hypertrace-core-graphql | 2 +- .../build.gradle.kts | 34 ++++ .../LabelApplicationRuleSchemaFragment.java | 23 +++ .../LabelApplicationRuleSchemaModule.java | 21 +++ .../LabelApplicationRuleConfigServiceDao.java | 83 +++++++++ .../rules/dao/LabelApplicationRuleDao.java | 16 ++ .../dao/LabelApplicationRuleDaoModule.java | 18 ++ .../LabelApplicationRuleRequestConverter.java | 114 ++++++++++++ ...LabelApplicationRuleResponseConverter.java | 172 ++++++++++++++++++ ...lApplicationRuleDeserializationConfig.java | 129 +++++++++++++ ...lApplicationRuleDeserializationConfig.java | 27 +++ ...lApplicationRuleDeserializationModule.java | 18 ++ .../fetcher/LabelApplicationRuleFetcher.java | 39 ++++ .../LabelApplicationRuleCreateMutator.java | 41 +++++ .../LabelApplicationRuleCreateRequest.java | 8 + .../LabelApplicationRuleDeleteRequest.java | 8 + .../LabelApplicationRuleRequestBuilder.java | 12 ++ ...abelApplicationRuleRequestBuilderImpl.java | 55 ++++++ .../LabelApplicationRuleRequestModule.java | 12 ++ .../LabelApplicationRuleUpdateRequest.java | 7 + .../mutation/CreateLabelApplicationRule.java | 18 ++ .../LabelApplicationRuleMutationSchema.java | 20 ++ .../mutation/UpdateLabelApplicationRule.java | 3 + .../LabelApplicationRuleQuerySchema.java | 17 ++ .../query/LabelApplicationRuleResultSet.java | 19 ++ .../schema/shared/CompositeCondition.java | 31 ++++ .../rules/schema/shared/Condition.java | 10 + .../schema/shared/LabelApplicationRule.java | 23 +++ .../shared/LabelApplicationRuleData.java | 24 +++ .../rules/schema/shared/LeafCondition.java | 23 +++ .../rules/schema/shared/StringCondition.java | 30 +++ .../rules/schema/shared/UnaryCondition.java | 23 +++ .../rules/schema/shared/ValueCondition.java | 10 + hypertrace-graphql-platform/build.gradle.kts | 1 + settings.gradle.kts | 1 + 35 files changed, 1091 insertions(+), 1 deletion(-) create mode 100644 hypertrace-graphql-label-application-rules-schema/build.gradle.kts create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaFragment.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaModule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDaoModule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/fetcher/LabelApplicationRuleFetcher.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleCreateMutator.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestModule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleQuerySchema.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleResultSet.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java diff --git a/hypertrace-core-graphql b/hypertrace-core-graphql index 2360aefb..2edb2710 160000 --- a/hypertrace-core-graphql +++ b/hypertrace-core-graphql @@ -1 +1 @@ -Subproject commit 2360aefb1aac6e35dec0d88c2419b1c614eee41a +Subproject commit 2edb2710fd8645b6a1fe3369a3308707dd435926 diff --git a/hypertrace-graphql-label-application-rules-schema/build.gradle.kts b/hypertrace-graphql-label-application-rules-schema/build.gradle.kts new file mode 100644 index 00000000..a207d31a --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/build.gradle.kts @@ -0,0 +1,34 @@ +plugins { + `java-library` + jacoco + id("org.hypertrace.jacoco-report-plugin") +} + +dependencies { + api("com.google.inject:guice") + api("com.graphql-java:graphql-java") + api("org.hypertrace.core.graphql:hypertrace-core-graphql-spi") + api("io.github.graphql-java:graphql-java-annotations") + api("org.hypertrace.core.graphql:hypertrace-core-graphql-common-schema") + + annotationProcessor("org.projectlombok:lombok") + compileOnly("org.projectlombok:lombok") + + implementation("org.slf4j:slf4j-api") + implementation("io.reactivex.rxjava3:rxjava") + implementation("org.hypertrace.config.service:label-application-rule-config-service-api") + implementation("com.google.protobuf:protobuf-java-util") + implementation("com.google.guava:guava") + + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-context") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-grpc-utils") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-schema-utils") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-rx-utils") + implementation("org.hypertrace.core.graphql:hypertrace-core-graphql-deserialization") + + implementation(project(":hypertrace-graphql-service-config")) +} + +tasks.test { + useJUnitPlatform() +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaFragment.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaFragment.java new file mode 100644 index 00000000..2a2f6c17 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaFragment.java @@ -0,0 +1,23 @@ +package org.hypertrace.graphql.label.application.rules; + +import org.hypertrace.core.graphql.spi.schema.GraphQlSchemaFragment; +import org.hypertrace.graphql.label.application.rules.schema.mutation.LabelApplicationRuleMutationSchema; +import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleQuerySchema; + +public class LabelApplicationRuleSchemaFragment implements GraphQlSchemaFragment { + + @Override + public String fragmentName() { + return "Label Application Rules Schema"; + } + + @Override + public Class annotatedQueryClass() { + return LabelApplicationRuleQuerySchema.class; + } + + @Override + public Class annotatedMutationClass() { + return LabelApplicationRuleMutationSchema.class; + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaModule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaModule.java new file mode 100644 index 00000000..c3a37921 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/LabelApplicationRuleSchemaModule.java @@ -0,0 +1,21 @@ +package org.hypertrace.graphql.label.application.rules; + +import com.google.inject.AbstractModule; +import com.google.inject.multibindings.Multibinder; +import org.hypertrace.core.graphql.spi.schema.GraphQlSchemaFragment; +import org.hypertrace.graphql.label.application.rules.dao.LabelApplicationRuleDaoModule; +import org.hypertrace.graphql.label.application.rules.deserialization.LabelApplicationRuleDeserializationModule; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleRequestModule; + +public class LabelApplicationRuleSchemaModule extends AbstractModule { + @Override + protected void configure() { + Multibinder.newSetBinder(binder(), GraphQlSchemaFragment.class) + .addBinding() + .to(LabelApplicationRuleSchemaFragment.class); + + install(new LabelApplicationRuleDaoModule()); + install(new LabelApplicationRuleRequestModule()); + install(new LabelApplicationRuleDeserializationModule()); + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java new file mode 100644 index 00000000..01cfebb5 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java @@ -0,0 +1,83 @@ +package org.hypertrace.graphql.label.application.rules.dao; + +import io.grpc.CallCredentials; +import io.reactivex.rxjava3.core.Single; +import java.util.concurrent.TimeUnit; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.request.ContextualRequest; +import org.hypertrace.core.graphql.utils.grpc.GrpcChannelRegistry; +import org.hypertrace.core.graphql.utils.grpc.GrpcContextBuilder; +import org.hypertrace.graphql.config.HypertraceGraphQlServiceConfig; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; +import org.hypertrace.label.application.rule.config.service.v1.GetLabelApplicationRulesRequest; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleConfigServiceGrpc; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleConfigServiceGrpc.LabelApplicationRuleConfigServiceFutureStub; + +public class LabelApplicationRuleConfigServiceDao implements LabelApplicationRuleDao { + + private final LabelApplicationRuleConfigServiceFutureStub + labelApplicationRuleConfigServiceFutureStub; + private final GrpcContextBuilder grpcContextBuilder; + private final HypertraceGraphQlServiceConfig serviceConfig; + private final LabelApplicationRuleRequestConverter requestConverter; + private final LabelApplicationRuleResponseConverter responseConverter; + + @Inject + LabelApplicationRuleConfigServiceDao( + HypertraceGraphQlServiceConfig serviceConfig, + CallCredentials credentials, + GrpcContextBuilder grpcContextBuilder, + GrpcChannelRegistry grpcChannelRegistry, + LabelApplicationRuleRequestConverter requestConverter, + LabelApplicationRuleResponseConverter responseConverter) { + this.grpcContextBuilder = grpcContextBuilder; + this.serviceConfig = serviceConfig; + this.requestConverter = requestConverter; + this.responseConverter = responseConverter; + this.labelApplicationRuleConfigServiceFutureStub = + LabelApplicationRuleConfigServiceGrpc.newFutureStub( + grpcChannelRegistry.forAddress( + serviceConfig.getConfigServiceHost(), serviceConfig.getConfigServicePort())) + .withCallCredentials(credentials); + } + + @Override + public Single createLabelApplicationRule( + LabelApplicationRuleCreateRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.labelApplicationRuleConfigServiceFutureStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), + TimeUnit.MILLISECONDS) + .createLabelApplicationRule( + this.requestConverter.convertCreationRequest(request)))) + .flatMap(this.responseConverter::convertCreateLabelApplicationRuleResponse); + } + + @Override + public Single getLabelApplicationRules(ContextualRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.labelApplicationRuleConfigServiceFutureStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), + TimeUnit.MILLISECONDS) + .getLabelApplicationRules( + GetLabelApplicationRulesRequest.getDefaultInstance()))) + .flatMap(this.responseConverter::convertGetLabelApplicationsRuleResponse); + } + + @Override + public Single updateLabelApplicationRule(ContextualRequest request) { + return null; + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java new file mode 100644 index 00000000..c3723e1f --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java @@ -0,0 +1,16 @@ +package org.hypertrace.graphql.label.application.rules.dao; + +import io.reactivex.rxjava3.core.Single; +import org.hypertrace.core.graphql.common.request.ContextualRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; + +public interface LabelApplicationRuleDao { + Single createLabelApplicationRule( + LabelApplicationRuleCreateRequest request); + + Single getLabelApplicationRules(ContextualRequest request); + + Single updateLabelApplicationRule(ContextualRequest request); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDaoModule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDaoModule.java new file mode 100644 index 00000000..7f7387dc --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDaoModule.java @@ -0,0 +1,18 @@ +package org.hypertrace.graphql.label.application.rules.dao; + +import com.google.inject.AbstractModule; +import io.grpc.CallCredentials; +import org.hypertrace.core.graphql.spi.config.GraphQlServiceConfig; +import org.hypertrace.core.graphql.utils.grpc.GrpcChannelRegistry; +import org.hypertrace.core.graphql.utils.grpc.GrpcContextBuilder; + +public class LabelApplicationRuleDaoModule extends AbstractModule { + @Override + protected void configure() { + bind(LabelApplicationRuleDao.class).to(LabelApplicationRuleConfigServiceDao.class); + requireBinding(CallCredentials.class); + requireBinding(GraphQlServiceConfig.class); + requireBinding(GrpcChannelRegistry.class); + requireBinding(GrpcContextBuilder.class); + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java new file mode 100644 index 00000000..e625bef7 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -0,0 +1,114 @@ +package org.hypertrace.graphql.label.application.rules.dao; + +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; +import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; +import org.hypertrace.label.application.rule.config.service.v1.CreateLabelApplicationRuleRequest; + +public class LabelApplicationRuleRequestConverter { + CreateLabelApplicationRuleRequest convertCreationRequest( + LabelApplicationRuleCreateRequest labelApplicationRuleCreateRequest) { + LabelApplicationRuleData data = + labelApplicationRuleCreateRequest + .createLabelApplicationRuleRequest() + .labelApplicationRuleData(); + return CreateLabelApplicationRuleRequest.newBuilder() + .setData( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .newBuilder() + .setName(data.name()) + .setMatchingCondition(convertMatchingCondition(data.condition())) + .setLabelAction(convertLabelAction())) + .build(); + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition + convertMatchingCondition(Condition condition) { + if (condition.getClass().getName().equals(LeafCondition.class.getName())) { + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .Condition.newBuilder() + .setLeafCondition(convertLeafCondition((LeafCondition) condition)) + .build(); + } else { + throw new IllegalArgumentException("Error when parsing matching condition"); + } + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action + convertLabelAction() { + return null; + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition + convertLeafCondition(LeafCondition leafCondition) { + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition + .Builder + leafConditionBuilder = + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .LeafCondition.newBuilder() + .setKeyCondition(convertStringCondition(leafCondition.keyCondition())); + if (validateSameClass(leafCondition.valueCondition().getClass(), StringCondition.class)) { + return leafConditionBuilder + .setStringCondition( + convertStringCondition((StringCondition) leafCondition.valueCondition())) + .build(); + } + if (validateSameClass(leafCondition.valueCondition().getClass(), UnaryCondition.class)) { + return leafConditionBuilder + .setUnaryCondition(convertUnaryCondition((UnaryCondition) leafCondition.valueCondition())) + .build(); + } + throw new IllegalArgumentException("Unsupported Leaf Condition"); + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition + convertStringCondition(StringCondition stringCondition) { + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .StringCondition.newBuilder() + .setOperator(convertStringConditionOperator(stringCondition.operator())) + .setValue(stringCondition.value()) + .build(); + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.UnaryCondition + convertUnaryCondition(UnaryCondition unaryCondition) { + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .UnaryCondition.newBuilder() + .setOperator(convertUnaryOperator(unaryCondition.operator())) + .build(); + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition + .Operator + convertStringConditionOperator(StringCondition.Operator operator) { + switch (operator) { + case OPERATOR_EQUALS: + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .StringCondition.Operator.OPERATOR_EQUALS; + case OPERATOR_MATCHES_REGEX: + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .StringCondition.Operator.OPERATOR_MATCHES_REGEX; + default: + throw new IllegalArgumentException("Unsupported String Condition Operator"); + } + } + + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.UnaryCondition + .Operator + convertUnaryOperator(UnaryCondition.Operator operator) { + switch (operator) { + case OPERATOR_EXISTS: + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .UnaryCondition.Operator.OPERATOR_EXISTS; + default: + throw new IllegalArgumentException("Unsupported Unary Condition Operator"); + } + } + + private boolean validateSameClass(Class class1, Class class2) { + return class1.getName().equals(class2.getName()); + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java new file mode 100644 index 00000000..7ef118ac --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -0,0 +1,172 @@ +package org.hypertrace.graphql.label.application.rules.dao; + +import io.reactivex.rxjava3.core.Observable; +import io.reactivex.rxjava3.core.Single; +import java.util.List; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; +import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; +import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; +import org.hypertrace.label.application.rule.config.service.v1.CreateLabelApplicationRuleResponse; +import org.hypertrace.label.application.rule.config.service.v1.GetLabelApplicationRulesResponse; + +class LabelApplicationRuleResponseConverter { + + Single convertGetLabelApplicationsRuleResponse( + GetLabelApplicationRulesResponse response) { + return Observable.fromIterable(response.getLabelApplicationRulesList()) + .flatMapSingle(this::convertLabelApplicationRule) + .toList() + .map(ConvertedLabelApplicationRuleResultSet::forRuleList); + } + + Single convertCreateLabelApplicationRuleResponse( + CreateLabelApplicationRuleResponse response) { + return convertLabelApplicationRule(response.getLabelApplicationRule()); + } + + Single convertLabelApplicationRule( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRule rule) { + try { + return Single.just(DefaultLabelApplicationRule.of(rule)); + } catch (Exception exception) { + return Single.error(exception); + } + } + + @Value + @Accessors(fluent = true) + private static class DefaultLabelApplicationRule implements LabelApplicationRule { + private static LabelApplicationRule of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRule rule) { + return new DefaultLabelApplicationRule( + rule.getId(), DefaultLabelApplicationRuleData.of(rule.getData())); + } + + String id; + LabelApplicationRuleData labelApplicationRuleData; + } + + @Value + @Accessors(fluent = true) + private static class DefaultLabelApplicationRuleData implements LabelApplicationRuleData { + private static LabelApplicationRuleData of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData data) { + String ruleName = data.getName(); + Condition matchingCondition = DefaultCondition.of(data.getMatchingCondition()); + return new DefaultLabelApplicationRuleData(ruleName, matchingCondition); + } + + String name; + Condition condition; + } + + private static class DefaultCondition implements Condition { + private static Condition of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition + condition) { + switch (condition.getConditionCase()) { + case LEAF_CONDITION: + return DefaultLeafCondition.of(condition.getLeafCondition()); + case COMPOSITE_CONDITION: + default: + throw new IllegalArgumentException("Condition not set correctly"); + } + } + } + + @Value + @Accessors(fluent = true) + private static class DefaultLeafCondition implements LeafCondition { + private static LeafCondition of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .LeafCondition + leafCondition) { + return new DefaultLeafCondition( + DefaultStringCondition.of(leafCondition.getKeyCondition()), + DefaultValueCondition.of(leafCondition)); + } + + StringCondition keyCondition; + ValueCondition valueCondition; + } + + @Value + @Accessors(fluent = true) + private static class DefaultValueCondition implements ValueCondition { + private static ValueCondition of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .LeafCondition + leafCondition) { + switch (leafCondition.getConditionCase()) { + case STRING_CONDITION: + return DefaultStringCondition.of(leafCondition.getStringCondition()); + case UNARY_CONDITION: + return DefaultUnaryCondition.of(leafCondition.getUnaryCondition()); + case JSON_CONDITION: + default: + throw new IllegalArgumentException("Invalid operator in leaf condition"); + } + } + } + + @Value + @Accessors(fluent = true) + private static class DefaultUnaryCondition implements UnaryCondition { + private static UnaryCondition of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .UnaryCondition + unaryCondition) { + switch (unaryCondition.getOperator()) { + case OPERATOR_EXISTS: + return new DefaultUnaryCondition(Operator.OPERATOR_EXISTS); + case OPERATOR_UNSPECIFIED: + default: + throw new IllegalArgumentException("Operator not set in unary condition"); + } + } + + Operator operator; + } + + @Value + @Accessors(fluent = true) + private static class DefaultStringCondition implements StringCondition { + private static StringCondition of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .StringCondition + stringCondition) { + switch (stringCondition.getOperator()) { + case OPERATOR_EQUALS: + return new DefaultStringCondition(Operator.OPERATOR_EQUALS, stringCondition.getValue()); + case OPERATOR_MATCHES_REGEX: + return new DefaultStringCondition( + Operator.OPERATOR_MATCHES_REGEX, stringCondition.getValue()); + default: + throw new IllegalArgumentException("String Condition operator is not set"); + } + } + + Operator operator; + String value; + } + + @Value + @Accessors(fluent = true) + private static class ConvertedLabelApplicationRuleResultSet + implements LabelApplicationRuleResultSet { + private static LabelApplicationRuleResultSet forRuleList(List ruleList) { + return new ConvertedLabelApplicationRuleResultSet(ruleList, ruleList.size(), ruleList.size()); + } + + List results; + long total; + long count; + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java new file mode 100644 index 00000000..38c8d8be --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java @@ -0,0 +1,129 @@ +package org.hypertrace.graphql.label.application.rules.deserialization; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSubTypes; +import com.fasterxml.jackson.annotation.JsonSubTypes.Type; +import com.fasterxml.jackson.annotation.JsonTypeInfo; +import com.fasterxml.jackson.annotation.JsonTypeName; +import com.fasterxml.jackson.databind.Module; +import com.fasterxml.jackson.databind.module.SimpleModule; +import java.util.List; +import lombok.NoArgsConstructor; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; +import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; +import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; + +public class CreateLabelApplicationRuleDeserializationConfig + implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return CreateLabelApplicationRule.ARGUMENT_NAME; + } + + @Override + public Class getArgumentSchema() { + return CreateLabelApplicationRule.class; + } + + @Override + public List jacksonModules() { + return List.of( + new SimpleModule() + .addAbstractTypeMapping( + CreateLabelApplicationRule.class, CreateLabelApplicationRuleArgument.class) + .addAbstractTypeMapping( + LabelApplicationRuleData.class, LabelApplicationRuleDataArgument.class) + .addAbstractTypeMapping(Condition.class, ConditionArgument.class) + .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) + .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) + .addAbstractTypeMapping(StringCondition.class, StringConditionArgument.class) + .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class CreateLabelApplicationRuleArgument implements CreateLabelApplicationRule { + @JsonProperty(LABEL_APPLICATION_RULE_DATA) + LabelApplicationRuleData labelApplicationRuleData; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class LabelApplicationRuleDataArgument implements LabelApplicationRuleData { + @JsonProperty(NAME_KEY) + String name; + + @JsonProperty(CONDITION_KEY) + Condition condition; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type") + @JsonSubTypes({ + @Type(value = LeafConditionArgument.class, name = "LeafConditionArgument"), + @Type(value = CompositeConditionArgument.class, name = "CompositeConditionArgument") + }) + private static class ConditionArgument implements Condition {} + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + @JsonTypeName("LeafConditionArgument") + private static class LeafConditionArgument implements LeafCondition { + @JsonProperty(KEY_CONDITION_KEY) + StringCondition keyCondition; + + @JsonProperty(VALUE_CONDITION_KEY) + @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type") + @JsonSubTypes({ + @Type(value = StringConditionArgument.class, name = "StringConditionArgument"), + @Type(value = UnaryConditionArgument.class, name = "UnaryConditionArgument") + }) + ValueCondition valueCondition; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + @JsonTypeName("CompositeConditionArgument") + private static class CompositeConditionArgument implements CompositeCondition { + @JsonProperty(LOGICAL_OPERATOR_KEY) + LogicalOperator operator; + + @JsonProperty(CHILDREN_KEY) + List children; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + @JsonTypeName("StringConditionArgument") + private static class StringConditionArgument implements StringCondition { + @JsonProperty(OPERATOR_KEY) + Operator operator; + + @JsonProperty(VALUE_KEY) + String value; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + @JsonTypeName("UnaryConditionArgument") + private static class UnaryConditionArgument implements UnaryCondition { + @JsonProperty(OPERATOR_KEY) + Operator operator; + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java new file mode 100644 index 00000000..e6d9bc76 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -0,0 +1,27 @@ +package org.hypertrace.graphql.label.application.rules.deserialization; + +import com.fasterxml.jackson.databind.Module; +import java.util.List; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; + +public class LabelApplicationRuleDeserializationConfig implements ArgumentDeserializationConfig { + @Override + public String getArgumentKey() { + return null; + } + + @Override + public String getListArgumentKey() { + return ArgumentDeserializationConfig.super.getListArgumentKey(); + } + + @Override + public Class getArgumentSchema() { + return null; + } + + @Override + public List jacksonModules() { + return ArgumentDeserializationConfig.super.jacksonModules(); + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java new file mode 100644 index 00000000..4480c354 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java @@ -0,0 +1,18 @@ +package org.hypertrace.graphql.label.application.rules.deserialization; + +import com.google.inject.AbstractModule; +import com.google.inject.multibindings.Multibinder; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; + +public class LabelApplicationRuleDeserializationModule extends AbstractModule { + @Override + protected void configure() { + Multibinder deserializationConfigBinder = + Multibinder.newSetBinder(binder(), ArgumentDeserializationConfig.class); + + deserializationConfigBinder + .addBinding() + .to(CreateLabelApplicationRuleDeserializationConfig.class); + deserializationConfigBinder.addBinding().to(LabelApplicationRuleDeserializationConfig.class); + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/fetcher/LabelApplicationRuleFetcher.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/fetcher/LabelApplicationRuleFetcher.java new file mode 100644 index 00000000..444c7ddd --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/fetcher/LabelApplicationRuleFetcher.java @@ -0,0 +1,39 @@ +package org.hypertrace.graphql.label.application.rules.fetcher; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.core.graphql.common.request.ContextualRequestBuilder; +import org.hypertrace.graphql.label.application.rules.dao.LabelApplicationRuleDao; +import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; + +public class LabelApplicationRuleFetcher + extends InjectableDataFetcher { + public LabelApplicationRuleFetcher() { + super(LabelApplicationRuleFetcherImpl.class); + } + + static final class LabelApplicationRuleFetcherImpl + implements DataFetcher> { + private final ContextualRequestBuilder requestBuilder; + private final LabelApplicationRuleDao labelApplicationRuleDao; + + @Inject + LabelApplicationRuleFetcherImpl( + ContextualRequestBuilder requestBuilder, LabelApplicationRuleDao labelApplicationRuleDao) { + this.requestBuilder = requestBuilder; + this.labelApplicationRuleDao = labelApplicationRuleDao; + } + + @Override + public CompletableFuture get( + DataFetchingEnvironment environment) { + return this.labelApplicationRuleDao + .getLabelApplicationRules(this.requestBuilder.build(environment.getContext())) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleCreateMutator.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleCreateMutator.java new file mode 100644 index 00000000..d8fe6fb1 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleCreateMutator.java @@ -0,0 +1,41 @@ +package org.hypertrace.graphql.label.application.rules.mutator; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.graphql.label.application.rules.dao.LabelApplicationRuleDao; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleRequestBuilder; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; + +public class LabelApplicationRuleCreateMutator extends InjectableDataFetcher { + + public LabelApplicationRuleCreateMutator() { + super(LabelApplicationRuleCreateMutatorImpl.class); + } + + static final class LabelApplicationRuleCreateMutatorImpl + implements DataFetcher> { + private final LabelApplicationRuleRequestBuilder requestBuilder; + private final LabelApplicationRuleDao labelApplicationRuleDao; + + @Inject + LabelApplicationRuleCreateMutatorImpl( + LabelApplicationRuleRequestBuilder requestBuilder, + LabelApplicationRuleDao labelApplicationRuleDao) { + this.requestBuilder = requestBuilder; + this.labelApplicationRuleDao = labelApplicationRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + return this.labelApplicationRuleDao + .createLabelApplicationRule( + this.requestBuilder.buildCreateLabelApplicationRuleRequest( + environment.getContext(), environment.getArguments())) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java new file mode 100644 index 00000000..12345b8b --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java @@ -0,0 +1,8 @@ +package org.hypertrace.graphql.label.application.rules.request; + +import org.hypertrace.core.graphql.common.request.ContextualRequest; +import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; + +public interface LabelApplicationRuleCreateRequest extends ContextualRequest { + CreateLabelApplicationRule createLabelApplicationRuleRequest(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java new file mode 100644 index 00000000..884cf577 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java @@ -0,0 +1,8 @@ +package org.hypertrace.graphql.label.application.rules.request; + +import org.hypertrace.core.graphql.common.request.ContextualRequest; +import org.hypertrace.label.application.rule.config.service.v1.DeleteLabelApplicationRuleRequest; + +public interface LabelApplicationRuleDeleteRequest extends ContextualRequest { + DeleteLabelApplicationRuleRequest deleteLabelApplicationRuleRequest(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java new file mode 100644 index 00000000..682a2509 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java @@ -0,0 +1,12 @@ +package org.hypertrace.graphql.label.application.rules.request; + +import java.util.Map; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; + +public interface LabelApplicationRuleRequestBuilder { + LabelApplicationRuleCreateRequest buildCreateLabelApplicationRuleRequest( + GraphQlRequestContext requestContext, Map arguments); + + LabelApplicationRuleUpdateRequest buildUpdateLabelApplicationRuleRequest( + GraphQlRequestContext requestContext, Map arguments); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java new file mode 100644 index 00000000..b2f433dc --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java @@ -0,0 +1,55 @@ +package org.hypertrace.graphql.label.application.rules.request; + +import java.util.Map; +import javax.inject.Inject; +import lombok.Value; +import lombok.experimental.Accessors; +import org.hypertrace.core.graphql.context.GraphQlRequestContext; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; +import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.mutation.UpdateLabelApplicationRule; + +public class LabelApplicationRuleRequestBuilderImpl implements LabelApplicationRuleRequestBuilder { + private final ArgumentDeserializer argumentDeserializer; + + @Inject + public LabelApplicationRuleRequestBuilderImpl(ArgumentDeserializer argumentDeserializer) { + this.argumentDeserializer = argumentDeserializer; + } + + @Override + public LabelApplicationRuleCreateRequest buildCreateLabelApplicationRuleRequest( + GraphQlRequestContext requestContext, Map arguments) { + return new LabelApplicationRuleCreateRequestImpl( + requestContext, + this.argumentDeserializer + .deserializeObject(arguments, CreateLabelApplicationRule.class) + .orElseThrow()); + } + + @Override + public LabelApplicationRuleUpdateRequest buildUpdateLabelApplicationRuleRequest( + GraphQlRequestContext requestContext, Map arguments) { + return new LabelApplicationRuleUpdateRequestImpl( + requestContext, + this.argumentDeserializer + .deserializeObject(arguments, UpdateLabelApplicationRule.class) + .orElseThrow()); + } + + @Value + @Accessors(fluent = true) + private static class LabelApplicationRuleCreateRequestImpl + implements LabelApplicationRuleCreateRequest { + GraphQlRequestContext context; + CreateLabelApplicationRule createLabelApplicationRuleRequest; + } + + @Value + @Accessors(fluent = true) + private static class LabelApplicationRuleUpdateRequestImpl + implements LabelApplicationRuleUpdateRequest { + GraphQlRequestContext context; + UpdateLabelApplicationRule updateLabelApplicationRuleRequest; + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestModule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestModule.java new file mode 100644 index 00000000..4ef58515 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestModule.java @@ -0,0 +1,12 @@ +package org.hypertrace.graphql.label.application.rules.request; + +import com.google.inject.AbstractModule; +import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; + +public class LabelApplicationRuleRequestModule extends AbstractModule { + @Override + protected void configure() { + bind(LabelApplicationRuleRequestBuilder.class).to(LabelApplicationRuleRequestBuilderImpl.class); + requireBinding(ArgumentDeserializer.class); + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java new file mode 100644 index 00000000..852075c3 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java @@ -0,0 +1,7 @@ +package org.hypertrace.graphql.label.application.rules.request; + +import org.hypertrace.graphql.label.application.rules.schema.mutation.UpdateLabelApplicationRule; + +public interface LabelApplicationRuleUpdateRequest { + UpdateLabelApplicationRule updateLabelApplicationRuleRequest(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java new file mode 100644 index 00000000..def07d39 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java @@ -0,0 +1,18 @@ +package org.hypertrace.graphql.label.application.rules.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; + +@GraphQLName(CreateLabelApplicationRule.TYPE_NAME) +public interface CreateLabelApplicationRule { + String TYPE_NAME = "CreateLabelApplicationRule"; + String ARGUMENT_NAME = "LabelApplicationRuleCreateRequest"; + String LABEL_APPLICATION_RULE_DATA = "LabelApplicationRuleData"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(LABEL_APPLICATION_RULE_DATA) + LabelApplicationRuleData labelApplicationRuleData(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java new file mode 100644 index 00000000..15f3f596 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java @@ -0,0 +1,20 @@ +package org.hypertrace.graphql.label.application.rules.schema.mutation; + +import graphql.annotations.annotationTypes.GraphQLDataFetcher; +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.graphql.label.application.rules.mutator.LabelApplicationRuleCreateMutator; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; + +public interface LabelApplicationRuleMutationSchema { + String CREATE_LABEL_APPLICATION_RULE = "createLabelApplicationRule"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(CREATE_LABEL_APPLICATION_RULE) + @GraphQLDataFetcher(LabelApplicationRuleCreateMutator.class) + LabelApplicationRule createLabelApplicationRule( + @GraphQLNonNull @GraphQLName(CreateLabelApplicationRule.ARGUMENT_NAME) + CreateLabelApplicationRule labelApplicationRule); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java new file mode 100644 index 00000000..873ccfa5 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java @@ -0,0 +1,3 @@ +package org.hypertrace.graphql.label.application.rules.schema.mutation; + +public interface UpdateLabelApplicationRule {} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleQuerySchema.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleQuerySchema.java new file mode 100644 index 00000000..bcde3c49 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleQuerySchema.java @@ -0,0 +1,17 @@ +package org.hypertrace.graphql.label.application.rules.schema.query; + +import graphql.annotations.annotationTypes.GraphQLDataFetcher; +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.graphql.label.application.rules.fetcher.LabelApplicationRuleFetcher; + +public interface LabelApplicationRuleQuerySchema { + String LABEL_APPLICATION_RULE_QUERY_NAME = "labelApplicationRules"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(LABEL_APPLICATION_RULE_QUERY_NAME) + @GraphQLDataFetcher(LabelApplicationRuleFetcher.class) + LabelApplicationRuleResultSet labelApplicationRules(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleResultSet.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleResultSet.java new file mode 100644 index 00000000..3f002bf9 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/query/LabelApplicationRuleResultSet.java @@ -0,0 +1,19 @@ +package org.hypertrace.graphql.label.application.rules.schema.query; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; +import org.hypertrace.core.graphql.common.schema.results.ResultSet; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; + +@GraphQLName(LabelApplicationRuleResultSet.TYPE_NAME) +public interface LabelApplicationRuleResultSet extends ResultSet { + String TYPE_NAME = "LabelApplicationRuleResultSet"; + + @Override + @GraphQLField + @GraphQLNonNull + @GraphQLName(RESULT_SET_RESULTS_NAME) + List results(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java new file mode 100644 index 00000000..8a34204f --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java @@ -0,0 +1,31 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; + +@GraphQLName(CompositeCondition.TYPE_NAME) +public interface CompositeCondition extends Condition { + String TYPE_NAME = "CompositeCondition"; + + String LOGICAL_OPERATOR_KEY = "LogicalOperator"; + String CHILDREN_KEY = "ChildConditions"; + + @GraphQLName(StringCondition.Operator.TYPE_NAME) + enum LogicalOperator { + LOGICAL_OPERATOR_AND, + LOGICAL_OPERATOR_OR; + static final String TYPE_NAME = "LogicalOperator"; + } + + @GraphQLField + @GraphQLNonNull + @GraphQLName(LOGICAL_OPERATOR_KEY) + LogicalOperator operator(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(CHILDREN_KEY) + List children(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java new file mode 100644 index 00000000..a0938d90 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLUnion; + +@GraphQLName(Condition.TYPE_NAME) +@GraphQLUnion(possibleTypes = {LeafCondition.class, CompositeCondition.class}) +public interface Condition { + String TYPE_NAME = "Condition"; +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java new file mode 100644 index 00000000..cf0e2825 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java @@ -0,0 +1,23 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(LabelApplicationRule.TYPE_NAME) +public interface LabelApplicationRule { + String TYPE_NAME = "LabelApplicationRule"; + + String ID_KEY = "Id"; + String LABEL_APPLICATION_RULE_DATA_KEY = "LabelApplicationRuleData"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(ID_KEY) + String id(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(LABEL_APPLICATION_RULE_DATA_KEY) + LabelApplicationRuleData labelApplicationRuleData(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java new file mode 100644 index 00000000..7638aad8 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java @@ -0,0 +1,24 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(LabelApplicationRuleData.TYPE_NAME) +public interface LabelApplicationRuleData { + String TYPE_NAME = "LabelApplicationRuleData"; + + String NAME_KEY = "name"; + String CONDITION_KEY = "condition"; + String ACTION_KEY = "action"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(NAME_KEY) + String name(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(CONDITION_KEY) + Condition condition(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java new file mode 100644 index 00000000..efb70b15 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java @@ -0,0 +1,23 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(LeafCondition.TYPE_NAME) +public interface LeafCondition extends Condition { + String TYPE_NAME = "LeafCondition"; + + String KEY_CONDITION_KEY = "KeyCondition"; + String VALUE_CONDITION_KEY = "ValueCondition"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(KEY_CONDITION_KEY) + StringCondition keyCondition(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(VALUE_CONDITION_KEY) + ValueCondition valueCondition(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java new file mode 100644 index 00000000..b7dc0589 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java @@ -0,0 +1,30 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(StringCondition.TYPE_NAME) +public interface StringCondition extends ValueCondition { + String TYPE_NAME = "StringCondition"; + + String OPERATOR_KEY = "Operator"; + String VALUE_KEY = "Value"; + + @GraphQLName(Operator.TYPE_NAME) + enum Operator { + OPERATOR_EQUALS, + OPERATOR_MATCHES_REGEX; + static final String TYPE_NAME = "Operator"; + } + + @GraphQLField + @GraphQLNonNull + @GraphQLName(OPERATOR_KEY) + Operator operator(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(VALUE_KEY) + String value(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java new file mode 100644 index 00000000..07ed458a --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java @@ -0,0 +1,23 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; + +@GraphQLName(UnaryCondition.TYPE_NAME) +public interface UnaryCondition extends ValueCondition { + String TYPE_NAME = "UnaryCondition"; + + String OPERATOR_KEY = "Operator"; + + @GraphQLName(Operator.TYPE_NAME) + enum Operator { + OPERATOR_EXISTS; + static final String TYPE_NAME = "Operator"; + } + + @GraphQLField + @GraphQLNonNull + @GraphQLName(OPERATOR_KEY) + Operator operator(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java new file mode 100644 index 00000000..684b1eb2 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java @@ -0,0 +1,10 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLUnion; + +@GraphQLName(ValueCondition.TYPE_NAME) +@GraphQLUnion(possibleTypes = {StringCondition.class, UnaryCondition.class}) +public interface ValueCondition { + String TYPE_NAME = "ValueCondition"; +} diff --git a/hypertrace-graphql-platform/build.gradle.kts b/hypertrace-graphql-platform/build.gradle.kts index d6d0f6bf..0611e171 100644 --- a/hypertrace-graphql-platform/build.gradle.kts +++ b/hypertrace-graphql-platform/build.gradle.kts @@ -12,5 +12,6 @@ dependencies { api("org.hypertrace.entity.service:entity-type-service-rx-client:0.5.6") api("org.hypertrace.config.service:spaces-config-service-api:0.1.1") api("org.hypertrace.config.service:labels-config-service-api:0.1.8") + api("org.hypertrace.config.service:label-application-rule-config-service-api:0.1.14") } } \ No newline at end of file diff --git a/settings.gradle.kts b/settings.gradle.kts index 7754a791..5b845ba3 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -26,3 +26,4 @@ include(":hypertrace-graphql-service-config") include(":hypertrace-graphql-platform") include(":hypertrace-graphql-spaces-schema") include(":hypertrace-graphql-labels-schema") +include(":hypertrace-graphql-label-application-rules-schema") \ No newline at end of file From 61e541701a963c008c2d174a9b084fcfe2d40d1d Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 27 Oct 2021 20:56:52 +0530 Subject: [PATCH 02/15] Implementing graphql apis for label application rules --- hypertrace-graphql-impl/build.gradle.kts | 1 + .../graphql/impl/GraphQlModule.java | 2 + .../LabelApplicationRuleRequestConverter.java | 44 +++++++++---------- ...LabelApplicationRuleResponseConverter.java | 26 +++++++++-- ...lApplicationRuleDeserializationConfig.java | 16 ++++--- .../schema/shared/CompositeCondition.java | 2 +- .../rules/schema/shared/Condition.java | 30 ++++++++++++- .../rules/schema/shared/LeafCondition.java | 2 +- .../rules/schema/shared/StringCondition.java | 2 +- .../rules/schema/shared/UnaryCondition.java | 2 +- .../rules/schema/shared/ValueCondition.java | 30 ++++++++++++- 11 files changed, 118 insertions(+), 39 deletions(-) diff --git a/hypertrace-graphql-impl/build.gradle.kts b/hypertrace-graphql-impl/build.gradle.kts index 90c3d9fb..af462d87 100644 --- a/hypertrace-graphql-impl/build.gradle.kts +++ b/hypertrace-graphql-impl/build.gradle.kts @@ -32,6 +32,7 @@ dependencies { implementation(project(":hypertrace-graphql-entity-type")) implementation(project(":hypertrace-graphql-spaces-schema")) implementation(project(":hypertrace-graphql-labels-schema")) + implementation(project(":hypertrace-graphql-label-application-rules-schema")) implementation("org.slf4j:slf4j-api") implementation("com.google.inject:guice") diff --git a/hypertrace-graphql-impl/src/main/java/org/hypertrace/graphql/impl/GraphQlModule.java b/hypertrace-graphql-impl/src/main/java/org/hypertrace/graphql/impl/GraphQlModule.java index 72e21f4a..f8198506 100644 --- a/hypertrace-graphql-impl/src/main/java/org/hypertrace/graphql/impl/GraphQlModule.java +++ b/hypertrace-graphql-impl/src/main/java/org/hypertrace/graphql/impl/GraphQlModule.java @@ -27,6 +27,7 @@ import org.hypertrace.graphql.explorer.ExplorerSchemaModule; import org.hypertrace.graphql.explorer.context.HypertraceExplorerContextModule; import org.hypertrace.graphql.label.LabelSchemaModule; +import org.hypertrace.graphql.label.application.rules.LabelApplicationRuleSchemaModule; import org.hypertrace.graphql.metric.MetricModule; import org.hypertrace.graphql.spaces.SpacesSchemaModule; import org.hypertrace.graphql.utils.metrics.gateway.GatewayMetricUtilsModule; @@ -73,5 +74,6 @@ protected void configure() { install(new SpacesSchemaModule()); install(new RequestTransformationModule()); install(new LabelSchemaModule()); + install(new LabelApplicationRuleSchemaModule()); } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index e625bef7..125f445e 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -27,13 +27,15 @@ CreateLabelApplicationRuleRequest convertCreationRequest( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition convertMatchingCondition(Condition condition) { - if (condition.getClass().getName().equals(LeafCondition.class.getName())) { - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .Condition.newBuilder() - .setLeafCondition(convertLeafCondition((LeafCondition) condition)) - .build(); - } else { - throw new IllegalArgumentException("Error when parsing matching condition"); + switch (condition.conditionType()) { + case LEAF_CONDITION: + return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .Condition.newBuilder() + .setLeafCondition(convertLeafCondition(condition.leafCondition())) + .build(); + case COMPOSITE_CONDITION: + default: + throw new IllegalArgumentException("Error when parsing matching condition"); } } @@ -50,18 +52,20 @@ CreateLabelApplicationRuleRequest convertCreationRequest( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData .LeafCondition.newBuilder() .setKeyCondition(convertStringCondition(leafCondition.keyCondition())); - if (validateSameClass(leafCondition.valueCondition().getClass(), StringCondition.class)) { - return leafConditionBuilder - .setStringCondition( - convertStringCondition((StringCondition) leafCondition.valueCondition())) - .build(); - } - if (validateSameClass(leafCondition.valueCondition().getClass(), UnaryCondition.class)) { - return leafConditionBuilder - .setUnaryCondition(convertUnaryCondition((UnaryCondition) leafCondition.valueCondition())) - .build(); + switch (leafCondition.valueCondition().valueConditionType()) { + case STRING_CONDITION: + return leafConditionBuilder + .setStringCondition( + convertStringCondition(leafCondition.valueCondition().stringCondition())) + .build(); + case UNARY_CONDITION: + return leafConditionBuilder + .setUnaryCondition( + convertUnaryCondition(leafCondition.valueCondition().unaryCondition())) + .build(); + default: + throw new IllegalArgumentException("Unsupported Leaf Condition"); } - throw new IllegalArgumentException("Unsupported Leaf Condition"); } org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition @@ -107,8 +111,4 @@ CreateLabelApplicationRuleRequest convertCreationRequest( throw new IllegalArgumentException("Unsupported Unary Condition Operator"); } } - - private boolean validateSameClass(Class class1, Class class2) { - return class1.getName().equals(class2.getName()); - } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index 7ef118ac..5b10c112 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -6,6 +6,7 @@ import lombok.Value; import lombok.experimental.Accessors; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; +import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; @@ -67,18 +68,27 @@ private static LabelApplicationRuleData of( Condition condition; } + @Value + @Accessors(fluent = true) private static class DefaultCondition implements Condition { private static Condition of( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition condition) { switch (condition.getConditionCase()) { case LEAF_CONDITION: - return DefaultLeafCondition.of(condition.getLeafCondition()); + return new DefaultCondition( + DefaultLeafCondition.of(condition.getLeafCondition()), + null, + ConditionType.LEAF_CONDITION); case COMPOSITE_CONDITION: default: throw new IllegalArgumentException("Condition not set correctly"); } } + + LeafCondition leafCondition; + CompositeCondition compositeCondition; + ConditionType conditionType; } @Value @@ -106,14 +116,24 @@ private static ValueCondition of( leafCondition) { switch (leafCondition.getConditionCase()) { case STRING_CONDITION: - return DefaultStringCondition.of(leafCondition.getStringCondition()); + return new DefaultValueCondition( + DefaultStringCondition.of(leafCondition.getStringCondition()), + null, + ValueConditionType.STRING_CONDITION); case UNARY_CONDITION: - return DefaultUnaryCondition.of(leafCondition.getUnaryCondition()); + return new DefaultValueCondition( + null, + DefaultUnaryCondition.of(leafCondition.getUnaryCondition()), + ValueConditionType.UNARY_CONDITION); case JSON_CONDITION: default: throw new IllegalArgumentException("Invalid operator in leaf condition"); } } + + StringCondition stringCondition; + UnaryCondition unaryCondition; + ValueConditionType valueConditionType; } @Value diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java index 38c8d8be..4963485e 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java @@ -70,12 +70,16 @@ private static class LabelApplicationRuleDataArgument implements LabelApplicatio @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) - @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type") - @JsonSubTypes({ - @Type(value = LeafConditionArgument.class, name = "LeafConditionArgument"), - @Type(value = CompositeConditionArgument.class, name = "CompositeConditionArgument") - }) - private static class ConditionArgument implements Condition {} + private static class ConditionArgument implements Condition { + @JsonProperty(LEAF_CONDITION_KEY) + LeafCondition leafCondition; + + @JsonProperty(COMPOSITE_CONDITION_KEY) + CompositeCondition compositeCondition; + + @JsonProperty(ConditionType.TYPE_NAME) + ConditionType conditionType; + } @Value @Accessors(fluent = true) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java index 8a34204f..c02bb89e 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java @@ -6,7 +6,7 @@ import java.util.List; @GraphQLName(CompositeCondition.TYPE_NAME) -public interface CompositeCondition extends Condition { +public interface CompositeCondition { String TYPE_NAME = "CompositeCondition"; String LOGICAL_OPERATOR_KEY = "LogicalOperator"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java index a0938d90..ec1457a4 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java @@ -1,10 +1,36 @@ package org.hypertrace.graphql.label.application.rules.schema.shared; +import graphql.annotations.annotationTypes.GraphQLField; import graphql.annotations.annotationTypes.GraphQLName; -import graphql.annotations.annotationTypes.GraphQLUnion; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import javax.annotation.Nullable; @GraphQLName(Condition.TYPE_NAME) -@GraphQLUnion(possibleTypes = {LeafCondition.class, CompositeCondition.class}) public interface Condition { String TYPE_NAME = "Condition"; + + String LEAF_CONDITION_KEY = "leafCondition"; + String COMPOSITE_CONDITION_KEY = "compositeCondition"; + + enum ConditionType { + LEAF_CONDITION, + COMPOSITE_CONDITION; + + public static final String TYPE_NAME = "ConditionType"; + } + + @GraphQLField + @GraphQLName(LEAF_CONDITION_KEY) + @Nullable + LeafCondition leafCondition(); + + @GraphQLField + @GraphQLName(COMPOSITE_CONDITION_KEY) + @Nullable + CompositeCondition compositeCondition(); + + @GraphQLField + @GraphQLName(ConditionType.TYPE_NAME) + @GraphQLNonNull + ConditionType conditionType(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java index efb70b15..4c307392 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java @@ -5,7 +5,7 @@ import graphql.annotations.annotationTypes.GraphQLNonNull; @GraphQLName(LeafCondition.TYPE_NAME) -public interface LeafCondition extends Condition { +public interface LeafCondition { String TYPE_NAME = "LeafCondition"; String KEY_CONDITION_KEY = "KeyCondition"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java index b7dc0589..3ccb0909 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java @@ -5,7 +5,7 @@ import graphql.annotations.annotationTypes.GraphQLNonNull; @GraphQLName(StringCondition.TYPE_NAME) -public interface StringCondition extends ValueCondition { +public interface StringCondition { String TYPE_NAME = "StringCondition"; String OPERATOR_KEY = "Operator"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java index 07ed458a..0bdd32dd 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java @@ -5,7 +5,7 @@ import graphql.annotations.annotationTypes.GraphQLNonNull; @GraphQLName(UnaryCondition.TYPE_NAME) -public interface UnaryCondition extends ValueCondition { +public interface UnaryCondition { String TYPE_NAME = "UnaryCondition"; String OPERATOR_KEY = "Operator"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java index 684b1eb2..7da50d82 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java @@ -1,10 +1,36 @@ package org.hypertrace.graphql.label.application.rules.schema.shared; +import graphql.annotations.annotationTypes.GraphQLField; import graphql.annotations.annotationTypes.GraphQLName; -import graphql.annotations.annotationTypes.GraphQLUnion; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import javax.annotation.Nullable; @GraphQLName(ValueCondition.TYPE_NAME) -@GraphQLUnion(possibleTypes = {StringCondition.class, UnaryCondition.class}) public interface ValueCondition { String TYPE_NAME = "ValueCondition"; + + String STRING_CONDITION_KEY = "leafCondition"; + String UNARY_CONDITION_KEY = "compositeCondition"; + + enum ValueConditionType { + STRING_CONDITION, + UNARY_CONDITION; + + public static final String TYPE_NAME = "ValueConditionType"; + } + + @GraphQLField + @GraphQLName(STRING_CONDITION_KEY) + @Nullable + StringCondition stringCondition(); + + @GraphQLField + @GraphQLName(UNARY_CONDITION_KEY) + @Nullable + UnaryCondition unaryCondition(); + + @GraphQLField + @GraphQLName(ValueConditionType.TYPE_NAME) + @GraphQLNonNull + ValueConditionType valueConditionType(); } From d357ce3f9fa59059068e46bfbc9622a28c52b1b0 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 27 Oct 2021 21:06:50 +0530 Subject: [PATCH 03/15] Implementing graphql apis for label application rules --- .../label/application/rules/schema/shared/ValueCondition.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java index 7da50d82..665b9275 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java @@ -9,8 +9,8 @@ public interface ValueCondition { String TYPE_NAME = "ValueCondition"; - String STRING_CONDITION_KEY = "leafCondition"; - String UNARY_CONDITION_KEY = "compositeCondition"; + String STRING_CONDITION_KEY = "stringCondition"; + String UNARY_CONDITION_KEY = "unaryCondition"; enum ValueConditionType { STRING_CONDITION, From ec9bcc9476f0f1370216216cc2f2d1d101fc59c6 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Thu, 28 Oct 2021 19:36:43 +0530 Subject: [PATCH 04/15] Implementing graphql apis for label application rules --- .../LabelApplicationRuleConfigServiceDao.java | 8 +- .../rules/dao/LabelApplicationRuleDao.java | 4 +- .../LabelApplicationRuleRequestConverter.java | 133 ++++++++++++------ ...LabelApplicationRuleResponseConverter.java | 58 +++++++- ...lApplicationRuleDeserializationConfig.java | 50 +++++-- .../LabelApplicationRuleUpdateRequest.java | 3 +- .../rules/schema/shared/Action.java | 56 ++++++++ .../schema/shared/CompositeCondition.java | 8 +- .../rules/schema/shared/Condition.java | 7 +- .../schema/shared/LabelApplicationRule.java | 4 +- .../shared/LabelApplicationRuleData.java | 5 + .../rules/schema/shared/LeafCondition.java | 4 +- .../rules/schema/shared/StaticLabels.java | 18 +++ .../rules/schema/shared/StringCondition.java | 6 +- .../rules/schema/shared/UnaryCondition.java | 4 +- .../rules/schema/shared/ValueCondition.java | 3 +- 16 files changed, 289 insertions(+), 82 deletions(-) create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java index 01cfebb5..5aca69c8 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java @@ -9,13 +9,14 @@ import org.hypertrace.core.graphql.utils.grpc.GrpcContextBuilder; import org.hypertrace.graphql.config.HypertraceGraphQlServiceConfig; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleUpdateRequest; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; import org.hypertrace.label.application.rule.config.service.v1.GetLabelApplicationRulesRequest; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleConfigServiceGrpc; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleConfigServiceGrpc.LabelApplicationRuleConfigServiceFutureStub; -public class LabelApplicationRuleConfigServiceDao implements LabelApplicationRuleDao { +class LabelApplicationRuleConfigServiceDao implements LabelApplicationRuleDao { private final LabelApplicationRuleConfigServiceFutureStub labelApplicationRuleConfigServiceFutureStub; @@ -77,7 +78,8 @@ public Single getLabelApplicationRules(Contextual } @Override - public Single updateLabelApplicationRule(ContextualRequest request) { - return null; + public Single updateLabelApplicationRule( + LabelApplicationRuleUpdateRequest request) { + return Single.error(new UnsupportedOperationException("Not yet implemented")); } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java index c3723e1f..c75c021c 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java @@ -3,6 +3,7 @@ import io.reactivex.rxjava3.core.Single; import org.hypertrace.core.graphql.common.request.ContextualRequest; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleUpdateRequest; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; @@ -12,5 +13,6 @@ Single createLabelApplicationRule( Single getLabelApplicationRules(ContextualRequest request); - Single updateLabelApplicationRule(ContextualRequest request); + Single updateLabelApplicationRule( + LabelApplicationRuleUpdateRequest request); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index 125f445e..9436189e 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -1,57 +1,104 @@ package org.hypertrace.graphql.label.application.rules.dao; +import java.util.stream.Collectors; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; -import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; -import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; -import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; -import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; -import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; import org.hypertrace.label.application.rule.config.service.v1.CreateLabelApplicationRuleRequest; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.CompositeCondition; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition; +import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.UnaryCondition; -public class LabelApplicationRuleRequestConverter { +class LabelApplicationRuleRequestConverter { CreateLabelApplicationRuleRequest convertCreationRequest( LabelApplicationRuleCreateRequest labelApplicationRuleCreateRequest) { - LabelApplicationRuleData data = + org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData data = labelApplicationRuleCreateRequest .createLabelApplicationRuleRequest() .labelApplicationRuleData(); return CreateLabelApplicationRuleRequest.newBuilder() .setData( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .newBuilder() + LabelApplicationRuleData.newBuilder() .setName(data.name()) .setMatchingCondition(convertMatchingCondition(data.condition())) - .setLabelAction(convertLabelAction())) + .setLabelAction(convertLabelAction(data.action()))) .build(); } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition - convertMatchingCondition(Condition condition) { + Condition convertMatchingCondition( + org.hypertrace.graphql.label.application.rules.schema.shared.Condition condition) { switch (condition.conditionType()) { case LEAF_CONDITION: - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .Condition.newBuilder() + return Condition.newBuilder() .setLeafCondition(convertLeafCondition(condition.leafCondition())) .build(); case COMPOSITE_CONDITION: + return Condition.newBuilder() + .setCompositeCondition(convertCompositeCondition(condition.compositeCondition())) + .build(); default: throw new IllegalArgumentException("Error when parsing matching condition"); } } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action - convertLabelAction() { - return null; + Action convertLabelAction( + org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { + Action.Builder actionBuilder = Action.newBuilder().addAllEntityTypes(action.entityTypes()); + + switch (action.operation()) { + case OPERATION_MERGE: + actionBuilder.setOperation(Action.Operation.OPERATION_MERGE); + break; + default: + throw new IllegalArgumentException("Unsupported Operation"); + } + + switch (action.valueType()) { + case STATIC_LABELS: + return actionBuilder + .setStaticLabels( + Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()) + .build(); + case DYNAMIC_LABEL_KEY: + return actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()).build(); + default: + throw new IllegalArgumentException("Unsupported action value"); + } + } + + CompositeCondition convertCompositeCondition( + org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition + compositeCondition) { + CompositeCondition.Builder compositeConditionBuilder = + CompositeCondition.newBuilder() + .addAllChildren( + compositeCondition.children().stream() + .map(this::convertLeafCondition) + .map( + leafCondition -> + Condition.newBuilder().setLeafCondition(leafCondition).build()) + .collect(Collectors.toList())); + switch (compositeCondition.operator()) { + case LOGICAL_OPERATOR_AND: + return compositeConditionBuilder + .setOperator(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_AND) + .build(); + case LOGICAL_OPERATOR_OR: + return compositeConditionBuilder + .setOperator(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_OR) + .build(); + default: + throw new IllegalArgumentException("Composite Condition Conversion Failed"); + } } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition - convertLeafCondition(LeafCondition leafCondition) { - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition - .Builder - leafConditionBuilder = - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .LeafCondition.newBuilder() - .setKeyCondition(convertStringCondition(leafCondition.keyCondition())); + LeafCondition convertLeafCondition( + org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition leafCondition) { + LeafCondition.Builder leafConditionBuilder = + LeafCondition.newBuilder() + .setKeyCondition(convertStringCondition(leafCondition.keyCondition())); switch (leafCondition.valueCondition().valueConditionType()) { case STRING_CONDITION: return leafConditionBuilder @@ -68,45 +115,41 @@ CreateLabelApplicationRuleRequest convertCreationRequest( } } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition - convertStringCondition(StringCondition stringCondition) { - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .StringCondition.newBuilder() + StringCondition convertStringCondition( + org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition + stringCondition) { + return StringCondition.newBuilder() .setOperator(convertStringConditionOperator(stringCondition.operator())) .setValue(stringCondition.value()) .build(); } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.UnaryCondition - convertUnaryCondition(UnaryCondition unaryCondition) { - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .UnaryCondition.newBuilder() + UnaryCondition convertUnaryCondition( + org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition unaryCondition) { + return UnaryCondition.newBuilder() .setOperator(convertUnaryOperator(unaryCondition.operator())) .build(); } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition - .Operator - convertStringConditionOperator(StringCondition.Operator operator) { + StringCondition.Operator convertStringConditionOperator( + org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition.Operator + operator) { switch (operator) { case OPERATOR_EQUALS: - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .StringCondition.Operator.OPERATOR_EQUALS; + return StringCondition.Operator.OPERATOR_EQUALS; case OPERATOR_MATCHES_REGEX: - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .StringCondition.Operator.OPERATOR_MATCHES_REGEX; + return StringCondition.Operator.OPERATOR_MATCHES_REGEX; default: throw new IllegalArgumentException("Unsupported String Condition Operator"); } } - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.UnaryCondition - .Operator - convertUnaryOperator(UnaryCondition.Operator operator) { + UnaryCondition.Operator convertUnaryOperator( + org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition.Operator + operator) { switch (operator) { case OPERATOR_EXISTS: - return org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .UnaryCondition.Operator.OPERATOR_EXISTS; + return UnaryCondition.Operator.OPERATOR_EXISTS; default: throw new IllegalArgumentException("Unsupported Unary Condition Operator"); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index 5b10c112..f43645ab 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -6,11 +6,13 @@ import lombok.Value; import lombok.experimental.Accessors; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; +import org.hypertrace.graphql.label.application.rules.schema.shared.Action; import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.StaticLabels; import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; @@ -19,6 +21,7 @@ class LabelApplicationRuleResponseConverter { + // TODO: Refactor logic into convert methods from the static methods Single convertGetLabelApplicationsRuleResponse( GetLabelApplicationRulesResponse response) { return Observable.fromIterable(response.getLabelApplicationRulesList()) @@ -61,11 +64,64 @@ private static LabelApplicationRuleData of( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData data) { String ruleName = data.getName(); Condition matchingCondition = DefaultCondition.of(data.getMatchingCondition()); - return new DefaultLabelApplicationRuleData(ruleName, matchingCondition); + Action action = DefaultAction.of(data.getLabelAction()); + return new DefaultLabelApplicationRuleData(ruleName, matchingCondition, action); } String name; Condition condition; + Action action; + } + + @Value + @Accessors(fluent = true) + private static class DefaultAction implements Action { + private static Action of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action + action) { + List entityTypes = action.getEntityTypesList(); + Operation operation; + switch (action.getOperation()) { + case OPERATION_MERGE: + operation = Operation.OPERATION_MERGE; + break; + default: + throw new IllegalArgumentException("Invalid operation in label"); + } + switch (action.getValueCase()) { + case STATIC_LABELS: + return new DefaultAction( + entityTypes, + operation, + DefaultStaticLabels.of(action.getStaticLabels()), + null, + ValueType.STATIC_LABELS); + case DYNAMIC_LABEL_KEY: + return new DefaultAction( + entityTypes, operation, null, action.getDynamicLabelKey(), ValueType.STATIC_LABELS); + default: + throw new IllegalArgumentException("Unsupported value type in action"); + } + } + + List entityTypes; + Operation operation; + StaticLabels staticLabels; + String dynamicLabelKey; + ValueType valueType; + } + + @Value + @Accessors(fluent = true) + private static class DefaultStaticLabels implements StaticLabels { + private static StaticLabels of( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action + .StaticLabels + staticLabels) { + return new DefaultStaticLabels(staticLabels.getIdsList()); + } + + List ids; } @Value diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java index 4963485e..db407df8 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java @@ -1,10 +1,6 @@ package org.hypertrace.graphql.label.application.rules.deserialization; import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonSubTypes; -import com.fasterxml.jackson.annotation.JsonSubTypes.Type; -import com.fasterxml.jackson.annotation.JsonTypeInfo; -import com.fasterxml.jackson.annotation.JsonTypeName; import com.fasterxml.jackson.databind.Module; import com.fasterxml.jackson.databind.module.SimpleModule; import java.util.List; @@ -13,10 +9,12 @@ import lombok.experimental.Accessors; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.Action; import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.StaticLabels; import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; @@ -41,6 +39,8 @@ public List jacksonModules() { CreateLabelApplicationRule.class, CreateLabelApplicationRuleArgument.class) .addAbstractTypeMapping( LabelApplicationRuleData.class, LabelApplicationRuleDataArgument.class) + .addAbstractTypeMapping(Action.class, ActionArgument.class) + .addAbstractTypeMapping(StaticLabels.class, StaticLabelsArgument.class) .addAbstractTypeMapping(Condition.class, ConditionArgument.class) .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) @@ -65,6 +65,37 @@ private static class LabelApplicationRuleDataArgument implements LabelApplicatio @JsonProperty(CONDITION_KEY) Condition condition; + + @JsonProperty(ACTION_KEY) + Action action; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class ActionArgument implements Action { + @JsonProperty(ENTITY_TYPES_KEY) + List entityTypes; + + @JsonProperty(OPERATION_KEY) + Operation operation; + + @JsonProperty(STATIC_LABELS) + StaticLabels staticLabels; + + @JsonProperty(DYNAMIC_LABEL_KEY_KEY) + String dynamicLabelKey; + + @JsonProperty(VALUE_TYPE_KEY) + ValueType valueType; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class StaticLabelsArgument implements StaticLabels { + @JsonProperty(IDS_KEY) + List ids; } @Value @@ -77,31 +108,24 @@ private static class ConditionArgument implements Condition { @JsonProperty(COMPOSITE_CONDITION_KEY) CompositeCondition compositeCondition; - @JsonProperty(ConditionType.TYPE_NAME) + @JsonProperty(CONDITION_TYPE_KEY) ConditionType conditionType; } @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) - @JsonTypeName("LeafConditionArgument") private static class LeafConditionArgument implements LeafCondition { @JsonProperty(KEY_CONDITION_KEY) StringCondition keyCondition; @JsonProperty(VALUE_CONDITION_KEY) - @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type") - @JsonSubTypes({ - @Type(value = StringConditionArgument.class, name = "StringConditionArgument"), - @Type(value = UnaryConditionArgument.class, name = "UnaryConditionArgument") - }) ValueCondition valueCondition; } @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) - @JsonTypeName("CompositeConditionArgument") private static class CompositeConditionArgument implements CompositeCondition { @JsonProperty(LOGICAL_OPERATOR_KEY) LogicalOperator operator; @@ -113,7 +137,6 @@ private static class CompositeConditionArgument implements CompositeCondition { @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) - @JsonTypeName("StringConditionArgument") private static class StringConditionArgument implements StringCondition { @JsonProperty(OPERATOR_KEY) Operator operator; @@ -125,7 +148,6 @@ private static class StringConditionArgument implements StringCondition { @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) - @JsonTypeName("UnaryConditionArgument") private static class UnaryConditionArgument implements UnaryCondition { @JsonProperty(OPERATOR_KEY) Operator operator; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java index 852075c3..a788076e 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java @@ -1,7 +1,8 @@ package org.hypertrace.graphql.label.application.rules.request; +import org.hypertrace.core.graphql.common.request.ContextualRequest; import org.hypertrace.graphql.label.application.rules.schema.mutation.UpdateLabelApplicationRule; -public interface LabelApplicationRuleUpdateRequest { +public interface LabelApplicationRuleUpdateRequest extends ContextualRequest { UpdateLabelApplicationRule updateLabelApplicationRuleRequest(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java new file mode 100644 index 00000000..0d5779b0 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java @@ -0,0 +1,56 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; +import javax.annotation.Nullable; + +@GraphQLName(Action.TYPE_NAME) +public interface Action { + String TYPE_NAME = "Action"; + + String ENTITY_TYPES_KEY = "entityTypes"; + String OPERATION_KEY = "operation"; + String STATIC_LABELS = "staticLabels"; + String DYNAMIC_LABEL_KEY_KEY = "dynamicLabelKey"; + String VALUE_TYPE_KEY = "valueType"; + + @GraphQLName(Operation.TYPE_NAME) + enum Operation { + OPERATION_MERGE; + private static final String TYPE_NAME = "ActionOperator"; + } + + @GraphQLName(ValueType.TYPE_NAME) + enum ValueType { + STATIC_LABELS, + DYNAMIC_LABEL_KEY; + private static final String TYPE_NAME = "ValueType"; + } + + @GraphQLField + @GraphQLNonNull + @GraphQLName(ENTITY_TYPES_KEY) + List entityTypes(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(OPERATION_KEY) + Operation operation(); + + @GraphQLField + @Nullable + @GraphQLName(STATIC_LABELS) + StaticLabels staticLabels(); + + @GraphQLField + @Nullable + @GraphQLName(DYNAMIC_LABEL_KEY_KEY) + String dynamicLabelKey(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(VALUE_TYPE_KEY) + ValueType valueType(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java index c02bb89e..89673703 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java @@ -9,14 +9,14 @@ public interface CompositeCondition { String TYPE_NAME = "CompositeCondition"; - String LOGICAL_OPERATOR_KEY = "LogicalOperator"; - String CHILDREN_KEY = "ChildConditions"; + String LOGICAL_OPERATOR_KEY = "operator"; + String CHILDREN_KEY = "children"; - @GraphQLName(StringCondition.Operator.TYPE_NAME) + @GraphQLName(LogicalOperator.TYPE_NAME) enum LogicalOperator { LOGICAL_OPERATOR_AND, LOGICAL_OPERATOR_OR; - static final String TYPE_NAME = "LogicalOperator"; + private static final String TYPE_NAME = "LogicalOperator"; } @GraphQLField diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java index ec1457a4..4236ed63 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java @@ -11,12 +11,13 @@ public interface Condition { String LEAF_CONDITION_KEY = "leafCondition"; String COMPOSITE_CONDITION_KEY = "compositeCondition"; + String CONDITION_TYPE_KEY = "conditionType"; + @GraphQLName(ConditionType.TYPE_NAME) enum ConditionType { LEAF_CONDITION, COMPOSITE_CONDITION; - - public static final String TYPE_NAME = "ConditionType"; + private static final String TYPE_NAME = "ConditionType"; } @GraphQLField @@ -30,7 +31,7 @@ enum ConditionType { CompositeCondition compositeCondition(); @GraphQLField - @GraphQLName(ConditionType.TYPE_NAME) + @GraphQLName(CONDITION_TYPE_KEY) @GraphQLNonNull ConditionType conditionType(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java index cf0e2825..1b5e35a5 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java @@ -8,8 +8,8 @@ public interface LabelApplicationRule { String TYPE_NAME = "LabelApplicationRule"; - String ID_KEY = "Id"; - String LABEL_APPLICATION_RULE_DATA_KEY = "LabelApplicationRuleData"; + String ID_KEY = "id"; + String LABEL_APPLICATION_RULE_DATA_KEY = "labelApplicationRuleData"; @GraphQLField @GraphQLNonNull diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java index 7638aad8..6d0c8702 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java @@ -21,4 +21,9 @@ public interface LabelApplicationRuleData { @GraphQLNonNull @GraphQLName(CONDITION_KEY) Condition condition(); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(ACTION_KEY) + Action action(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java index 4c307392..d86c3878 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java @@ -8,8 +8,8 @@ public interface LeafCondition { String TYPE_NAME = "LeafCondition"; - String KEY_CONDITION_KEY = "KeyCondition"; - String VALUE_CONDITION_KEY = "ValueCondition"; + String KEY_CONDITION_KEY = "keyCondition"; + String VALUE_CONDITION_KEY = "valueCondition"; @GraphQLField @GraphQLNonNull diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java new file mode 100644 index 00000000..c590382d --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java @@ -0,0 +1,18 @@ +package org.hypertrace.graphql.label.application.rules.schema.shared; + +import graphql.annotations.annotationTypes.GraphQLField; +import graphql.annotations.annotationTypes.GraphQLName; +import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; + +@GraphQLName(StaticLabels.TYPE_NAME) +public interface StaticLabels { + String TYPE_NAME = "StaticLabels"; + + String IDS_KEY = "ids"; + + @GraphQLField + @GraphQLNonNull + @GraphQLName(IDS_KEY) + List ids(); +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java index 3ccb0909..52a77606 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java @@ -8,14 +8,14 @@ public interface StringCondition { String TYPE_NAME = "StringCondition"; - String OPERATOR_KEY = "Operator"; - String VALUE_KEY = "Value"; + String OPERATOR_KEY = "operator"; + String VALUE_KEY = "value"; @GraphQLName(Operator.TYPE_NAME) enum Operator { OPERATOR_EQUALS, OPERATOR_MATCHES_REGEX; - static final String TYPE_NAME = "Operator"; + private static final String TYPE_NAME = "StringConditionOperator"; } @GraphQLField diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java index 0bdd32dd..90836475 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java @@ -8,12 +8,12 @@ public interface UnaryCondition { String TYPE_NAME = "UnaryCondition"; - String OPERATOR_KEY = "Operator"; + String OPERATOR_KEY = "operator"; @GraphQLName(Operator.TYPE_NAME) enum Operator { OPERATOR_EXISTS; - static final String TYPE_NAME = "Operator"; + private static final String TYPE_NAME = "UnaryConditionOperator"; } @GraphQLField diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java index 665b9275..dc9b3ce3 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java @@ -12,11 +12,12 @@ public interface ValueCondition { String STRING_CONDITION_KEY = "stringCondition"; String UNARY_CONDITION_KEY = "unaryCondition"; + @GraphQLName(ValueConditionType.TYPE_NAME) enum ValueConditionType { STRING_CONDITION, UNARY_CONDITION; - public static final String TYPE_NAME = "ValueConditionType"; + private static final String TYPE_NAME = "ValueConditionType"; } @GraphQLField From f1c2541cf9e7f9cdbca0a3afef94b9a508f26c22 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Fri, 29 Oct 2021 13:00:28 +0530 Subject: [PATCH 05/15] Implementing graphql apis for label application rules --- .../LabelApplicationRuleConfigServiceDao.java | 31 +++- .../rules/dao/LabelApplicationRuleDao.java | 3 + .../LabelApplicationRuleRequestConverter.java | 46 ++++-- ...LabelApplicationRuleResponseConverter.java | 10 ++ ...icationRuleDataDeserializationConfig.java} | 17 +- ...lApplicationRuleDeserializationConfig.java | 145 +++++++++++++++++- ...lApplicationRuleDeserializationModule.java | 9 +- .../LabelApplicationRuleIdArgument.java | 7 + .../LabelApplicationRuleDeleteMutator.java | 39 +++++ .../LabelApplicationRuleUpdateMutator.java | 41 +++++ .../LabelApplicationRuleCreateRequest.java | 4 +- .../LabelApplicationRuleDeleteRequest.java | 3 +- .../LabelApplicationRuleRequestBuilder.java | 3 + ...abelApplicationRuleRequestBuilderImpl.java | 31 +++- .../LabelApplicationRuleUpdateRequest.java | 4 +- .../mutation/CreateLabelApplicationRule.java | 18 --- .../LabelApplicationRuleMutationSchema.java | 25 ++- .../mutation/UpdateLabelApplicationRule.java | 3 - .../rules/schema/shared/Action.java | 2 +- .../schema/shared/CompositeCondition.java | 2 +- .../rules/schema/shared/Condition.java | 2 +- .../schema/shared/LabelApplicationRule.java | 1 + .../shared/LabelApplicationRuleData.java | 1 + .../rules/schema/shared/LeafCondition.java | 2 +- .../rules/schema/shared/StaticLabels.java | 2 +- .../rules/schema/shared/StringCondition.java | 2 +- .../rules/schema/shared/UnaryCondition.java | 2 +- .../rules/schema/shared/ValueCondition.java | 2 +- 28 files changed, 380 insertions(+), 77 deletions(-) rename hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/{CreateLabelApplicationRuleDeserializationConfig.java => LabelApplicationRuleDataDeserializationConfig.java} (87%) create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleIdArgument.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleDeleteMutator.java create mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleUpdateMutator.java delete mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java delete mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java index 5aca69c8..40d0a2a0 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleConfigServiceDao.java @@ -9,6 +9,7 @@ import org.hypertrace.core.graphql.utils.grpc.GrpcContextBuilder; import org.hypertrace.graphql.config.HypertraceGraphQlServiceConfig; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleDeleteRequest; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleUpdateRequest; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; @@ -80,6 +81,34 @@ public Single getLabelApplicationRules(Contextual @Override public Single updateLabelApplicationRule( LabelApplicationRuleUpdateRequest request) { - return Single.error(new UnsupportedOperationException("Not yet implemented")); + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.labelApplicationRuleConfigServiceFutureStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), + TimeUnit.MILLISECONDS) + .updateLabelApplicationRule( + this.requestConverter.convertUpdateRequest(request)))) + .flatMap(this.responseConverter::convertUpdateLabelApplicationRuleResponse); + } + + @Override + public Single deleteLabelApplicationRule(LabelApplicationRuleDeleteRequest request) { + return Single.fromFuture( + this.grpcContextBuilder + .build(request.context()) + .call( + () -> + this.labelApplicationRuleConfigServiceFutureStub + .withDeadlineAfter( + serviceConfig.getConfigServiceTimeout().toMillis(), + TimeUnit.MILLISECONDS) + .deleteLabelApplicationRule( + this.requestConverter.convertDeleteRequest(request)))) + .flatMap( + unusedResponse -> this.responseConverter.buildDeleteLabelApplicationRuleResponse()); } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java index c75c021c..a52ea49d 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleDao.java @@ -3,6 +3,7 @@ import io.reactivex.rxjava3.core.Single; import org.hypertrace.core.graphql.common.request.ContextualRequest; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleDeleteRequest; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleUpdateRequest; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; @@ -15,4 +16,6 @@ Single createLabelApplicationRule( Single updateLabelApplicationRule( LabelApplicationRuleUpdateRequest request); + + Single deleteLabelApplicationRule(LabelApplicationRuleDeleteRequest request); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index 9436189e..b988e8a2 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -2,7 +2,10 @@ import java.util.stream.Collectors; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleDeleteRequest; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleUpdateRequest; import org.hypertrace.label.application.rule.config.service.v1.CreateLabelApplicationRuleRequest; +import org.hypertrace.label.application.rule.config.service.v1.DeleteLabelApplicationRuleRequest; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.CompositeCondition; @@ -10,24 +13,47 @@ import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.StringCondition; import org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.UnaryCondition; +import org.hypertrace.label.application.rule.config.service.v1.UpdateLabelApplicationRuleRequest; class LabelApplicationRuleRequestConverter { - CreateLabelApplicationRuleRequest convertCreationRequest( + public CreateLabelApplicationRuleRequest convertCreationRequest( LabelApplicationRuleCreateRequest labelApplicationRuleCreateRequest) { org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData data = - labelApplicationRuleCreateRequest - .createLabelApplicationRuleRequest() - .labelApplicationRuleData(); + labelApplicationRuleCreateRequest.labelApplicationRuleData(); return CreateLabelApplicationRuleRequest.newBuilder() + .setData(convertLabelApplicationRuleData(data)) + .build(); + } + + public UpdateLabelApplicationRuleRequest convertUpdateRequest( + LabelApplicationRuleUpdateRequest labelApplicationRuleUpdateRequest) { + return UpdateLabelApplicationRuleRequest.newBuilder() + .setId(labelApplicationRuleUpdateRequest.labelApplicationRule().id()) .setData( - LabelApplicationRuleData.newBuilder() - .setName(data.name()) - .setMatchingCondition(convertMatchingCondition(data.condition())) - .setLabelAction(convertLabelAction(data.action()))) + convertLabelApplicationRuleData( + labelApplicationRuleUpdateRequest + .labelApplicationRule() + .labelApplicationRuleData())) + .build(); + } + + public DeleteLabelApplicationRuleRequest convertDeleteRequest( + LabelApplicationRuleDeleteRequest labelApplicationRuleDeleteRequest) { + return DeleteLabelApplicationRuleRequest.newBuilder() + .setId(labelApplicationRuleDeleteRequest.id()) + .build(); + } + + private LabelApplicationRuleData convertLabelApplicationRuleData( + org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData data) { + return LabelApplicationRuleData.newBuilder() + .setName(data.name()) + .setMatchingCondition(convertMatchingCondition(data.condition())) + .setLabelAction(convertLabelAction(data.action())) .build(); } - Condition convertMatchingCondition( + private Condition convertMatchingCondition( org.hypertrace.graphql.label.application.rules.schema.shared.Condition condition) { switch (condition.conditionType()) { case LEAF_CONDITION: @@ -43,7 +69,7 @@ Condition convertMatchingCondition( } } - Action convertLabelAction( + private Action convertLabelAction( org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { Action.Builder actionBuilder = Action.newBuilder().addAllEntityTypes(action.entityTypes()); diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index f43645ab..917cd6ce 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -18,6 +18,7 @@ import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; import org.hypertrace.label.application.rule.config.service.v1.CreateLabelApplicationRuleResponse; import org.hypertrace.label.application.rule.config.service.v1.GetLabelApplicationRulesResponse; +import org.hypertrace.label.application.rule.config.service.v1.UpdateLabelApplicationRuleResponse; class LabelApplicationRuleResponseConverter { @@ -35,6 +36,15 @@ Single convertCreateLabelApplicationRuleResponse( return convertLabelApplicationRule(response.getLabelApplicationRule()); } + Single convertUpdateLabelApplicationRuleResponse( + UpdateLabelApplicationRuleResponse response) { + return convertLabelApplicationRule(response.getLabelApplicationRule()); + } + + Single buildDeleteLabelApplicationRuleResponse() { + return Single.just(true); + } + Single convertLabelApplicationRule( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRule rule) { try { diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java similarity index 87% rename from hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java rename to hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java index db407df8..78ba16ce 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/CreateLabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java @@ -8,7 +8,6 @@ import lombok.Value; import lombok.experimental.Accessors; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; -import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; import org.hypertrace.graphql.label.application.rules.schema.shared.Action; import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; @@ -19,24 +18,22 @@ import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; -public class CreateLabelApplicationRuleDeserializationConfig +public class LabelApplicationRuleDataDeserializationConfig implements ArgumentDeserializationConfig { @Override public String getArgumentKey() { - return CreateLabelApplicationRule.ARGUMENT_NAME; + return LabelApplicationRuleData.ARGUMENT_NAME; } @Override public Class getArgumentSchema() { - return CreateLabelApplicationRule.class; + return LabelApplicationRuleData.class; } @Override public List jacksonModules() { return List.of( new SimpleModule() - .addAbstractTypeMapping( - CreateLabelApplicationRule.class, CreateLabelApplicationRuleArgument.class) .addAbstractTypeMapping( LabelApplicationRuleData.class, LabelApplicationRuleDataArgument.class) .addAbstractTypeMapping(Action.class, ActionArgument.class) @@ -48,14 +45,6 @@ public List jacksonModules() { .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); } - @Value - @Accessors(fluent = true) - @NoArgsConstructor(force = true) - private static class CreateLabelApplicationRuleArgument implements CreateLabelApplicationRule { - @JsonProperty(LABEL_APPLICATION_RULE_DATA) - LabelApplicationRuleData labelApplicationRuleData; - } - @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java index e6d9bc76..0d63ad73 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -1,27 +1,156 @@ package org.hypertrace.graphql.label.application.rules.deserialization; +import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.Module; +import com.fasterxml.jackson.databind.module.SimpleModule; import java.util.List; +import lombok.NoArgsConstructor; +import lombok.Value; +import lombok.experimental.Accessors; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; +import org.hypertrace.graphql.label.application.rules.schema.shared.Action; +import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; +import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.StaticLabels; +import org.hypertrace.graphql.label.application.rules.schema.shared.StringCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.UnaryCondition; +import org.hypertrace.graphql.label.application.rules.schema.shared.ValueCondition; public class LabelApplicationRuleDeserializationConfig implements ArgumentDeserializationConfig { @Override public String getArgumentKey() { - return null; - } - - @Override - public String getListArgumentKey() { - return ArgumentDeserializationConfig.super.getListArgumentKey(); + return LabelApplicationRule.ARGUMENT_NAME; } @Override public Class getArgumentSchema() { - return null; + return LabelApplicationRule.class; } @Override public List jacksonModules() { - return ArgumentDeserializationConfig.super.jacksonModules(); + return List.of( + new SimpleModule() + .addAbstractTypeMapping(LabelApplicationRule.class, LabelApplicationRuleArgument.class) + .addAbstractTypeMapping( + LabelApplicationRuleData.class, LabelApplicationRuleDataArgument.class) + .addAbstractTypeMapping(Action.class, ActionArgument.class) + .addAbstractTypeMapping(StaticLabels.class, StaticLabelsArgument.class) + .addAbstractTypeMapping(Condition.class, ConditionArgument.class) + .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) + .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) + .addAbstractTypeMapping(StringCondition.class, StringConditionArgument.class) + .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class LabelApplicationRuleArgument implements LabelApplicationRule { + @JsonProperty(ID_KEY) + String id; + + @JsonProperty(LABEL_APPLICATION_RULE_DATA_KEY) + LabelApplicationRuleData labelApplicationRuleData; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class LabelApplicationRuleDataArgument implements LabelApplicationRuleData { + @JsonProperty(NAME_KEY) + String name; + + @JsonProperty(CONDITION_KEY) + Condition condition; + + @JsonProperty(ACTION_KEY) + Action action; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class ActionArgument implements Action { + @JsonProperty(ENTITY_TYPES_KEY) + List entityTypes; + + @JsonProperty(OPERATION_KEY) + Operation operation; + + @JsonProperty(STATIC_LABELS) + StaticLabels staticLabels; + + @JsonProperty(DYNAMIC_LABEL_KEY_KEY) + String dynamicLabelKey; + + @JsonProperty(VALUE_TYPE_KEY) + ValueType valueType; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class StaticLabelsArgument implements StaticLabels { + @JsonProperty(IDS_KEY) + List ids; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class ConditionArgument implements Condition { + @JsonProperty(LEAF_CONDITION_KEY) + LeafCondition leafCondition; + + @JsonProperty(COMPOSITE_CONDITION_KEY) + CompositeCondition compositeCondition; + + @JsonProperty(CONDITION_TYPE_KEY) + ConditionType conditionType; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class LeafConditionArgument implements LeafCondition { + @JsonProperty(KEY_CONDITION_KEY) + StringCondition keyCondition; + + @JsonProperty(VALUE_CONDITION_KEY) + ValueCondition valueCondition; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class CompositeConditionArgument implements CompositeCondition { + @JsonProperty(LOGICAL_OPERATOR_KEY) + LogicalOperator operator; + + @JsonProperty(CHILDREN_KEY) + List children; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class StringConditionArgument implements StringCondition { + @JsonProperty(OPERATOR_KEY) + Operator operator; + + @JsonProperty(VALUE_KEY) + String value; + } + + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class UnaryConditionArgument implements UnaryCondition { + @JsonProperty(OPERATOR_KEY) + Operator operator; } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java index 4480c354..a280c1a5 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationModule.java @@ -12,7 +12,14 @@ protected void configure() { deserializationConfigBinder .addBinding() - .to(CreateLabelApplicationRuleDeserializationConfig.class); + .to(LabelApplicationRuleDataDeserializationConfig.class); deserializationConfigBinder.addBinding().to(LabelApplicationRuleDeserializationConfig.class); + + deserializationConfigBinder + .addBinding() + .toInstance( + ArgumentDeserializationConfig.forPrimitive( + LabelApplicationRuleIdArgument.ARGUMENT_NAME, + LabelApplicationRuleIdArgument.class)); } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleIdArgument.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleIdArgument.java new file mode 100644 index 00000000..b41688cc --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleIdArgument.java @@ -0,0 +1,7 @@ +package org.hypertrace.graphql.label.application.rules.deserialization; + +import org.hypertrace.core.graphql.deserialization.PrimitiveArgument; + +public interface LabelApplicationRuleIdArgument extends PrimitiveArgument { + String ARGUMENT_NAME = "id"; +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleDeleteMutator.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleDeleteMutator.java new file mode 100644 index 00000000..c2fadffe --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleDeleteMutator.java @@ -0,0 +1,39 @@ +package org.hypertrace.graphql.label.application.rules.mutator; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.graphql.label.application.rules.dao.LabelApplicationRuleDao; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleRequestBuilder; + +public class LabelApplicationRuleDeleteMutator extends InjectableDataFetcher { + public LabelApplicationRuleDeleteMutator() { + super(LabelApplicationRuleDeleteMutatorImpl.class); + } + + static final class LabelApplicationRuleDeleteMutatorImpl + implements DataFetcher> { + private final LabelApplicationRuleRequestBuilder requestBuilder; + private final LabelApplicationRuleDao labelApplicationRuleDao; + + @Inject + LabelApplicationRuleDeleteMutatorImpl( + LabelApplicationRuleRequestBuilder requestBuilder, + LabelApplicationRuleDao labelApplicationRuleDao) { + this.requestBuilder = requestBuilder; + this.labelApplicationRuleDao = labelApplicationRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + return this.labelApplicationRuleDao + .deleteLabelApplicationRule( + this.requestBuilder.buildDeleteLabelApplicationRuleRequest( + environment.getContext(), environment.getArguments())) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleUpdateMutator.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleUpdateMutator.java new file mode 100644 index 00000000..f9d8eea3 --- /dev/null +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/mutator/LabelApplicationRuleUpdateMutator.java @@ -0,0 +1,41 @@ +package org.hypertrace.graphql.label.application.rules.mutator; + +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; +import java.util.concurrent.CompletableFuture; +import javax.inject.Inject; +import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher; +import org.hypertrace.graphql.label.application.rules.dao.LabelApplicationRuleDao; +import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleRequestBuilder; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; + +public class LabelApplicationRuleUpdateMutator extends InjectableDataFetcher { + + public LabelApplicationRuleUpdateMutator() { + super(LabelApplicationRuleUpdateMutatorImpl.class); + } + + static final class LabelApplicationRuleUpdateMutatorImpl + implements DataFetcher> { + private final LabelApplicationRuleRequestBuilder requestBuilder; + private final LabelApplicationRuleDao labelApplicationRuleDao; + + @Inject + LabelApplicationRuleUpdateMutatorImpl( + LabelApplicationRuleRequestBuilder requestBuilder, + LabelApplicationRuleDao labelApplicationRuleDao) { + this.requestBuilder = requestBuilder; + this.labelApplicationRuleDao = labelApplicationRuleDao; + } + + @Override + public CompletableFuture get(DataFetchingEnvironment environment) { + return this.labelApplicationRuleDao + .updateLabelApplicationRule( + this.requestBuilder.buildUpdateLabelApplicationRuleRequest( + environment.getContext(), environment.getArguments())) + .toCompletionStage() + .toCompletableFuture(); + } + } +} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java index 12345b8b..2f9eb649 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleCreateRequest.java @@ -1,8 +1,8 @@ package org.hypertrace.graphql.label.application.rules.request; import org.hypertrace.core.graphql.common.request.ContextualRequest; -import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; public interface LabelApplicationRuleCreateRequest extends ContextualRequest { - CreateLabelApplicationRule createLabelApplicationRuleRequest(); + LabelApplicationRuleData labelApplicationRuleData(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java index 884cf577..c7425dd4 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleDeleteRequest.java @@ -1,8 +1,7 @@ package org.hypertrace.graphql.label.application.rules.request; import org.hypertrace.core.graphql.common.request.ContextualRequest; -import org.hypertrace.label.application.rule.config.service.v1.DeleteLabelApplicationRuleRequest; public interface LabelApplicationRuleDeleteRequest extends ContextualRequest { - DeleteLabelApplicationRuleRequest deleteLabelApplicationRuleRequest(); + String id(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java index 682a2509..589aaf2a 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilder.java @@ -9,4 +9,7 @@ LabelApplicationRuleCreateRequest buildCreateLabelApplicationRuleRequest( LabelApplicationRuleUpdateRequest buildUpdateLabelApplicationRuleRequest( GraphQlRequestContext requestContext, Map arguments); + + LabelApplicationRuleDeleteRequest buildDeleteLabelApplicationRuleRequest( + GraphQlRequestContext requestContext, Map arguments); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java index b2f433dc..cde65c0a 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleRequestBuilderImpl.java @@ -6,8 +6,9 @@ import lombok.experimental.Accessors; import org.hypertrace.core.graphql.context.GraphQlRequestContext; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer; -import org.hypertrace.graphql.label.application.rules.schema.mutation.CreateLabelApplicationRule; -import org.hypertrace.graphql.label.application.rules.schema.mutation.UpdateLabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.deserialization.LabelApplicationRuleIdArgument; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; public class LabelApplicationRuleRequestBuilderImpl implements LabelApplicationRuleRequestBuilder { private final ArgumentDeserializer argumentDeserializer; @@ -23,7 +24,7 @@ public LabelApplicationRuleCreateRequest buildCreateLabelApplicationRuleRequest( return new LabelApplicationRuleCreateRequestImpl( requestContext, this.argumentDeserializer - .deserializeObject(arguments, CreateLabelApplicationRule.class) + .deserializeObject(arguments, LabelApplicationRuleData.class) .orElseThrow()); } @@ -33,7 +34,17 @@ public LabelApplicationRuleUpdateRequest buildUpdateLabelApplicationRuleRequest( return new LabelApplicationRuleUpdateRequestImpl( requestContext, this.argumentDeserializer - .deserializeObject(arguments, UpdateLabelApplicationRule.class) + .deserializeObject(arguments, LabelApplicationRule.class) + .orElseThrow()); + } + + @Override + public LabelApplicationRuleDeleteRequest buildDeleteLabelApplicationRuleRequest( + GraphQlRequestContext requestContext, Map arguments) { + return new LabelApplicationRuleIdArgumentImpl( + requestContext, + this.argumentDeserializer + .deserializePrimitive(arguments, LabelApplicationRuleIdArgument.class) .orElseThrow()); } @@ -42,7 +53,7 @@ public LabelApplicationRuleUpdateRequest buildUpdateLabelApplicationRuleRequest( private static class LabelApplicationRuleCreateRequestImpl implements LabelApplicationRuleCreateRequest { GraphQlRequestContext context; - CreateLabelApplicationRule createLabelApplicationRuleRequest; + LabelApplicationRuleData labelApplicationRuleData; } @Value @@ -50,6 +61,14 @@ private static class LabelApplicationRuleCreateRequestImpl private static class LabelApplicationRuleUpdateRequestImpl implements LabelApplicationRuleUpdateRequest { GraphQlRequestContext context; - UpdateLabelApplicationRule updateLabelApplicationRuleRequest; + LabelApplicationRule labelApplicationRule; + } + + @Value + @Accessors(fluent = true) + private static class LabelApplicationRuleIdArgumentImpl + implements LabelApplicationRuleDeleteRequest { + GraphQlRequestContext context; + String id; } } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java index a788076e..04f8ffc2 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/request/LabelApplicationRuleUpdateRequest.java @@ -1,8 +1,8 @@ package org.hypertrace.graphql.label.application.rules.request; import org.hypertrace.core.graphql.common.request.ContextualRequest; -import org.hypertrace.graphql.label.application.rules.schema.mutation.UpdateLabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; public interface LabelApplicationRuleUpdateRequest extends ContextualRequest { - UpdateLabelApplicationRule updateLabelApplicationRuleRequest(); + LabelApplicationRule labelApplicationRule(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java deleted file mode 100644 index def07d39..00000000 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/CreateLabelApplicationRule.java +++ /dev/null @@ -1,18 +0,0 @@ -package org.hypertrace.graphql.label.application.rules.schema.mutation; - -import graphql.annotations.annotationTypes.GraphQLField; -import graphql.annotations.annotationTypes.GraphQLName; -import graphql.annotations.annotationTypes.GraphQLNonNull; -import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; - -@GraphQLName(CreateLabelApplicationRule.TYPE_NAME) -public interface CreateLabelApplicationRule { - String TYPE_NAME = "CreateLabelApplicationRule"; - String ARGUMENT_NAME = "LabelApplicationRuleCreateRequest"; - String LABEL_APPLICATION_RULE_DATA = "LabelApplicationRuleData"; - - @GraphQLField - @GraphQLNonNull - @GraphQLName(LABEL_APPLICATION_RULE_DATA) - LabelApplicationRuleData labelApplicationRuleData(); -} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java index 15f3f596..b811c638 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/LabelApplicationRuleMutationSchema.java @@ -4,17 +4,38 @@ import graphql.annotations.annotationTypes.GraphQLField; import graphql.annotations.annotationTypes.GraphQLName; import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.graphql.label.application.rules.deserialization.LabelApplicationRuleIdArgument; import org.hypertrace.graphql.label.application.rules.mutator.LabelApplicationRuleCreateMutator; +import org.hypertrace.graphql.label.application.rules.mutator.LabelApplicationRuleDeleteMutator; +import org.hypertrace.graphql.label.application.rules.mutator.LabelApplicationRuleUpdateMutator; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; +import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; public interface LabelApplicationRuleMutationSchema { String CREATE_LABEL_APPLICATION_RULE = "createLabelApplicationRule"; + String UPDATE_LABEL_APPLICATION_RULE = "updateLabelApplicationRule"; + String DELETE_LABEL_APPLICATION_RULE = "deleteLabelApplicationRule"; @GraphQLField @GraphQLNonNull @GraphQLName(CREATE_LABEL_APPLICATION_RULE) @GraphQLDataFetcher(LabelApplicationRuleCreateMutator.class) LabelApplicationRule createLabelApplicationRule( - @GraphQLNonNull @GraphQLName(CreateLabelApplicationRule.ARGUMENT_NAME) - CreateLabelApplicationRule labelApplicationRule); + @GraphQLNonNull @GraphQLName(LabelApplicationRuleData.ARGUMENT_NAME) + LabelApplicationRuleData labelApplicationRuleData); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(UPDATE_LABEL_APPLICATION_RULE) + @GraphQLDataFetcher(LabelApplicationRuleUpdateMutator.class) + LabelApplicationRule updateLabelApplicationRule( + @GraphQLNonNull @GraphQLName(LabelApplicationRule.ARGUMENT_NAME) + LabelApplicationRule labelApplicationRule); + + @GraphQLField + @GraphQLNonNull + @GraphQLName(DELETE_LABEL_APPLICATION_RULE) + @GraphQLDataFetcher(LabelApplicationRuleDeleteMutator.class) + Boolean deleteLabelApplicationRule( + @GraphQLNonNull @GraphQLName(LabelApplicationRuleIdArgument.ARGUMENT_NAME) String id); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java deleted file mode 100644 index 873ccfa5..00000000 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/mutation/UpdateLabelApplicationRule.java +++ /dev/null @@ -1,3 +0,0 @@ -package org.hypertrace.graphql.label.application.rules.schema.mutation; - -public interface UpdateLabelApplicationRule {} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java index 0d5779b0..d8ebb299 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java @@ -8,7 +8,7 @@ @GraphQLName(Action.TYPE_NAME) public interface Action { - String TYPE_NAME = "Action"; + String TYPE_NAME = "LabelApplicationAction"; String ENTITY_TYPES_KEY = "entityTypes"; String OPERATION_KEY = "operation"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java index 89673703..17e77805 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java @@ -7,7 +7,7 @@ @GraphQLName(CompositeCondition.TYPE_NAME) public interface CompositeCondition { - String TYPE_NAME = "CompositeCondition"; + String TYPE_NAME = "LabelApplicationCompositeCondition"; String LOGICAL_OPERATOR_KEY = "operator"; String CHILDREN_KEY = "children"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java index 4236ed63..d83048a1 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java @@ -7,7 +7,7 @@ @GraphQLName(Condition.TYPE_NAME) public interface Condition { - String TYPE_NAME = "Condition"; + String TYPE_NAME = "LabelApplicationCondition"; String LEAF_CONDITION_KEY = "leafCondition"; String COMPOSITE_CONDITION_KEY = "compositeCondition"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java index 1b5e35a5..3b993a46 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java @@ -7,6 +7,7 @@ @GraphQLName(LabelApplicationRule.TYPE_NAME) public interface LabelApplicationRule { String TYPE_NAME = "LabelApplicationRule"; + String ARGUMENT_NAME = "labelApplicationRule"; String ID_KEY = "id"; String LABEL_APPLICATION_RULE_DATA_KEY = "labelApplicationRuleData"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java index 6d0c8702..bc9be880 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java @@ -7,6 +7,7 @@ @GraphQLName(LabelApplicationRuleData.TYPE_NAME) public interface LabelApplicationRuleData { String TYPE_NAME = "LabelApplicationRuleData"; + String ARGUMENT_NAME = "labelApplicationRuleData"; String NAME_KEY = "name"; String CONDITION_KEY = "condition"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java index d86c3878..f5e60fa5 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LeafCondition.java @@ -6,7 +6,7 @@ @GraphQLName(LeafCondition.TYPE_NAME) public interface LeafCondition { - String TYPE_NAME = "LeafCondition"; + String TYPE_NAME = "LabelApplicationLeafCondition"; String KEY_CONDITION_KEY = "keyCondition"; String VALUE_CONDITION_KEY = "valueCondition"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java index c590382d..697a96de 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StaticLabels.java @@ -7,7 +7,7 @@ @GraphQLName(StaticLabels.TYPE_NAME) public interface StaticLabels { - String TYPE_NAME = "StaticLabels"; + String TYPE_NAME = "LabelApplicationStaticLabels"; String IDS_KEY = "ids"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java index 52a77606..d978293a 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/StringCondition.java @@ -6,7 +6,7 @@ @GraphQLName(StringCondition.TYPE_NAME) public interface StringCondition { - String TYPE_NAME = "StringCondition"; + String TYPE_NAME = "LabelApplicationStringCondition"; String OPERATOR_KEY = "operator"; String VALUE_KEY = "value"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java index 90836475..3887623a 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/UnaryCondition.java @@ -6,7 +6,7 @@ @GraphQLName(UnaryCondition.TYPE_NAME) public interface UnaryCondition { - String TYPE_NAME = "UnaryCondition"; + String TYPE_NAME = "LabelApplicationUnaryCondition"; String OPERATOR_KEY = "operator"; diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java index dc9b3ce3..7e8fc53b 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java @@ -7,7 +7,7 @@ @GraphQLName(ValueCondition.TYPE_NAME) public interface ValueCondition { - String TYPE_NAME = "ValueCondition"; + String TYPE_NAME = "LabelApplicationValueCondition"; String STRING_CONDITION_KEY = "stringCondition"; String UNARY_CONDITION_KEY = "unaryCondition"; From 6ed7e63e43bec8fb8bf2f54da65c0ff697532ff2 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Fri, 29 Oct 2021 13:15:01 +0530 Subject: [PATCH 06/15] Implementing graphql apis for label application rules --- .../LabelApplicationRuleRequestConverter.java | 30 ++++++++++++------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index b988e8a2..da311457 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -69,31 +69,39 @@ private Condition convertMatchingCondition( } } - private Action convertLabelAction( - org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { - Action.Builder actionBuilder = Action.newBuilder().addAllEntityTypes(action.entityTypes()); - - switch (action.operation()) { + private void setOperationInAction(org.hypertrace.graphql.label.application.rules.schema.shared.Action action, Action.Builder actionBuilder){ + switch(action.operation()){ case OPERATION_MERGE: actionBuilder.setOperation(Action.Operation.OPERATION_MERGE); - break; + return; default: throw new IllegalArgumentException("Unsupported Operation"); } + } + private void setLabelsInAction(org.hypertrace.graphql.label.application.rules.schema.shared.Action action, Action.Builder actionBuilder){ switch (action.valueType()) { case STATIC_LABELS: - return actionBuilder - .setStaticLabels( - Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()) - .build(); + actionBuilder + .setStaticLabels( + Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()); + return; case DYNAMIC_LABEL_KEY: - return actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()).build(); + actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()).build(); + return; default: throw new IllegalArgumentException("Unsupported action value"); } } + private Action convertLabelAction( + org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { + Action.Builder actionBuilder = Action.newBuilder().addAllEntityTypes(action.entityTypes()); + setOperationInAction(action, actionBuilder); + setLabelsInAction(action, actionBuilder); + return actionBuilder.build(); + } + CompositeCondition convertCompositeCondition( org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition compositeCondition) { From 3d132cd2ecbbe0f31c201b778a2558b40ff58758 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Fri, 29 Oct 2021 13:16:30 +0530 Subject: [PATCH 07/15] Implementing graphql apis for label application rules --- .../dao/LabelApplicationRuleRequestConverter.java | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index da311457..18c14f93 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -69,8 +69,10 @@ private Condition convertMatchingCondition( } } - private void setOperationInAction(org.hypertrace.graphql.label.application.rules.schema.shared.Action action, Action.Builder actionBuilder){ - switch(action.operation()){ + private void setOperationInAction( + org.hypertrace.graphql.label.application.rules.schema.shared.Action action, + Action.Builder actionBuilder) { + switch (action.operation()) { case OPERATION_MERGE: actionBuilder.setOperation(Action.Operation.OPERATION_MERGE); return; @@ -79,12 +81,13 @@ private void setOperationInAction(org.hypertrace.graphql.label.application.rules } } - private void setLabelsInAction(org.hypertrace.graphql.label.application.rules.schema.shared.Action action, Action.Builder actionBuilder){ + private void setLabelsInAction( + org.hypertrace.graphql.label.application.rules.schema.shared.Action action, + Action.Builder actionBuilder) { switch (action.valueType()) { case STATIC_LABELS: - actionBuilder - .setStaticLabels( - Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()); + actionBuilder.setStaticLabels( + Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()); return; case DYNAMIC_LABEL_KEY: actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()).build(); From 51d5e0642a4c451157280017d0ec42bc1da22ab3 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Fri, 29 Oct 2021 17:34:17 +0530 Subject: [PATCH 08/15] Implementing graphql apis for label application rules --- ...LabelApplicationRuleResponseConverter.java | 394 +++++++++++------- 1 file changed, 251 insertions(+), 143 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index 917cd6ce..edb5aff8 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -3,8 +3,11 @@ import io.reactivex.rxjava3.core.Observable; import io.reactivex.rxjava3.core.Single; import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; import lombok.Value; import lombok.experimental.Accessors; +import lombok.extern.slf4j.Slf4j; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; import org.hypertrace.graphql.label.application.rules.schema.shared.Action; import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; @@ -20,64 +23,270 @@ import org.hypertrace.label.application.rule.config.service.v1.GetLabelApplicationRulesResponse; import org.hypertrace.label.application.rule.config.service.v1.UpdateLabelApplicationRuleResponse; +@Slf4j class LabelApplicationRuleResponseConverter { + Single convertCreateLabelApplicationRuleResponse( + CreateLabelApplicationRuleResponse response) { + Optional rule = + convertLabelApplicationRule(response.getLabelApplicationRule()); + if (rule.isPresent()) { + return Single.just(rule.get()); + } else { + return Single.error(new IllegalArgumentException("Unable to convert rule create response")); + } + } - // TODO: Refactor logic into convert methods from the static methods Single convertGetLabelApplicationsRuleResponse( GetLabelApplicationRulesResponse response) { return Observable.fromIterable(response.getLabelApplicationRulesList()) - .flatMapSingle(this::convertLabelApplicationRule) + .map(this::convertLabelApplicationRule) + .flatMapSingle( + convertedRule -> { + if (convertedRule.isEmpty()) { + return Single.error( + new IllegalArgumentException("Unable to convert a rule in get all response")); + } + return Single.just(convertedRule.get()); + }) .toList() .map(ConvertedLabelApplicationRuleResultSet::forRuleList); } - Single convertCreateLabelApplicationRuleResponse( - CreateLabelApplicationRuleResponse response) { - return convertLabelApplicationRule(response.getLabelApplicationRule()); - } - Single convertUpdateLabelApplicationRuleResponse( UpdateLabelApplicationRuleResponse response) { - return convertLabelApplicationRule(response.getLabelApplicationRule()); + Optional rule = + convertLabelApplicationRule(response.getLabelApplicationRule()); + if (rule.isPresent()) { + return Single.just(rule.get()); + } else { + return Single.error(new IllegalArgumentException("Unable to convert rule update response")); + } } Single buildDeleteLabelApplicationRuleResponse() { return Single.just(true); } - Single convertLabelApplicationRule( + private Optional convertLabelApplicationRule( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRule rule) { - try { - return Single.just(DefaultLabelApplicationRule.of(rule)); - } catch (Exception exception) { - return Single.error(exception); + Optional ruleData = convertLabelApplicationRuleData(rule.getData()); + return ruleData.map(data -> new ConvertedLabelApplicationRule(rule.getId(), data)); + } + + private Optional convertLabelApplicationRuleData( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData data) { + Optional action = convertAction(data.getLabelAction()); + Optional condition = convertCondition(data.getMatchingCondition()); + if (condition.isEmpty() || action.isEmpty()) { + return Optional.empty(); } + return Optional.of( + new ConvertedLabelApplicationRuleData(data.getName(), condition.get(), action.get())); } - @Value - @Accessors(fluent = true) - private static class DefaultLabelApplicationRule implements LabelApplicationRule { - private static LabelApplicationRule of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRule rule) { - return new DefaultLabelApplicationRule( - rule.getId(), DefaultLabelApplicationRuleData.of(rule.getData())); + private Optional convertOperationInAction( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action + action) { + switch (action.getOperation()) { + case OPERATION_MERGE: + return Optional.of(Action.Operation.OPERATION_MERGE); + default: + log.error("Unrecognized Operation type in Action{}", action.getOperation().name()); + return Optional.empty(); + } + } + + private Optional convertAction( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action + action) { + List entityTypes = action.getEntityTypesList(); + Optional operation = convertOperationInAction(action); + if (operation.isEmpty()) { + return Optional.empty(); + } + switch (action.getValueCase()) { + case STATIC_LABELS: + StaticLabels staticLabels = convertStaticLabels(action.getStaticLabels()); + return Optional.of( + new ConvertedAction( + entityTypes, operation.get(), staticLabels, null, Action.ValueType.STATIC_LABELS)); + case DYNAMIC_LABEL_KEY: + return Optional.of( + new ConvertedAction( + entityTypes, + operation.get(), + null, + action.getDynamicLabelKey(), + Action.ValueType.STATIC_LABELS)); + default: + log.error("Unrecognized Value type in Action {}", action.getValueCase().name()); + return Optional.empty(); + } + } + + private StaticLabels convertStaticLabels( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action + .StaticLabels + staticLabels) { + return new ConvertedStaticLabels(staticLabels.getIdsList()); + } + + private Optional convertCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition + condition) { + switch (condition.getConditionCase()) { + case LEAF_CONDITION: + Optional leafCondition = convertLeafCondition(condition.getLeafCondition()); + return leafCondition.map( + leafCond -> + new ConvertedCondition(leafCond, null, Condition.ConditionType.LEAF_CONDITION)); + case COMPOSITE_CONDITION: + Optional compositeCondition = + convertCompositeCondition(condition.getCompositeCondition()); + return compositeCondition.map( + compositeCond -> + new ConvertedCondition( + null, compositeCond, Condition.ConditionType.COMPOSITE_CONDITION)); + default: + log.error("Unrecognized Condition Type {}", condition.getConditionCase().name()); + return Optional.empty(); + } + } + + private Optional convertCompositeCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .CompositeCondition + compositeCondition) { + List leafConditionList = + compositeCondition.getChildrenList().stream() + .filter(this::isLeafCondition) + .map(condition -> convertLeafCondition(condition.getLeafCondition())) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(Collectors.toList()); + if (leafConditionList.size() != compositeCondition.getChildrenList().size()) { + return Optional.empty(); + } + Optional logicalOperator = + convertLogicalOperator(compositeCondition); + return logicalOperator.map( + operator -> new ConvertedCompositeCondition(operator, leafConditionList)); + } + + private boolean isLeafCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition + condition) { + switch (condition.getConditionCase()) { + case LEAF_CONDITION: + return true; + case COMPOSITE_CONDITION: + default: + return false; + } + } + + private Optional convertLogicalOperator( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .CompositeCondition + compositeCondition) { + switch (compositeCondition.getOperator()) { + case LOGICAL_OPERATOR_AND: + return Optional.of(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_AND); + case LOGICAL_OPERATOR_OR: + return Optional.of(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_OR); + default: + log.error("Unrecognized Logical Operator in Composite Condition"); + return Optional.empty(); + } + } + + private Optional convertLeafCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition + leafCondition) { + Optional keyCondition = + convertStringCondition(leafCondition.getKeyCondition()); + Optional valueCondition = convertValueCondition(leafCondition); + if (keyCondition.isEmpty() || valueCondition.isEmpty()) { + return Optional.empty(); } + return Optional.of(new ConvertedLeafCondition(keyCondition.get(), valueCondition.get())); + } + + private Optional convertValueCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition + leafCondition) { + switch (leafCondition.getConditionCase()) { + case STRING_CONDITION: + Optional stringValueCondition = + convertStringCondition(leafCondition.getStringCondition()); + return stringValueCondition.map( + stringCondition -> + new ConvertedValueCondition( + stringCondition, null, ValueCondition.ValueConditionType.STRING_CONDITION)); + case UNARY_CONDITION: + Optional unaryValueCondition = + convertUnaryCondition(leafCondition.getUnaryCondition()); + return unaryValueCondition.map( + unaryCondition -> + new ConvertedValueCondition( + null, unaryCondition, ValueCondition.ValueConditionType.UNARY_CONDITION)); + case JSON_CONDITION: + default: + log.error("Unrecognized Value Condition Type {}", leafCondition.getConditionCase().name()); + return Optional.empty(); + } + } + private Optional convertStringCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .StringCondition + stringCondition) { + Optional operator = convertOperatorInStringCondition(stringCondition); + return operator.map(op -> new ConvertedStringCondition(op, stringCondition.getValue())); + } + + private Optional convertOperatorInStringCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .StringCondition + stringCondition) { + switch (stringCondition.getOperator()) { + case OPERATOR_EQUALS: + return Optional.of(StringCondition.Operator.OPERATOR_EQUALS); + case OPERATOR_MATCHES_REGEX: + return Optional.of(StringCondition.Operator.OPERATOR_MATCHES_REGEX); + default: + log.error( + "Unrecognized Operator Type in String Condition {}", + stringCondition.getOperator().name()); + return Optional.empty(); + } + } + + private Optional convertUnaryCondition( + org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData + .UnaryCondition + unaryCondition) { + switch (unaryCondition.getOperator()) { + case OPERATOR_EXISTS: + return Optional.of(new ConvertedUnaryCondition(UnaryCondition.Operator.OPERATOR_EXISTS)); + default: + log.error( + "Unrecognized Operator Type in Unary Condition {}", + unaryCondition.getOperator().name()); + return Optional.empty(); + } + } + + @Value + @Accessors(fluent = true) + private static class ConvertedLabelApplicationRule implements LabelApplicationRule { String id; LabelApplicationRuleData labelApplicationRuleData; } @Value @Accessors(fluent = true) - private static class DefaultLabelApplicationRuleData implements LabelApplicationRuleData { - private static LabelApplicationRuleData of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData data) { - String ruleName = data.getName(); - Condition matchingCondition = DefaultCondition.of(data.getMatchingCondition()); - Action action = DefaultAction.of(data.getLabelAction()); - return new DefaultLabelApplicationRuleData(ruleName, matchingCondition, action); - } - + private static class ConvertedLabelApplicationRuleData implements LabelApplicationRuleData { String name; Condition condition; Action action; @@ -85,35 +294,7 @@ private static LabelApplicationRuleData of( @Value @Accessors(fluent = true) - private static class DefaultAction implements Action { - private static Action of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action - action) { - List entityTypes = action.getEntityTypesList(); - Operation operation; - switch (action.getOperation()) { - case OPERATION_MERGE: - operation = Operation.OPERATION_MERGE; - break; - default: - throw new IllegalArgumentException("Invalid operation in label"); - } - switch (action.getValueCase()) { - case STATIC_LABELS: - return new DefaultAction( - entityTypes, - operation, - DefaultStaticLabels.of(action.getStaticLabels()), - null, - ValueType.STATIC_LABELS); - case DYNAMIC_LABEL_KEY: - return new DefaultAction( - entityTypes, operation, null, action.getDynamicLabelKey(), ValueType.STATIC_LABELS); - default: - throw new IllegalArgumentException("Unsupported value type in action"); - } - } - + private static class ConvertedAction implements Action { List entityTypes; Operation operation; StaticLabels staticLabels; @@ -123,35 +304,13 @@ private static Action of( @Value @Accessors(fluent = true) - private static class DefaultStaticLabels implements StaticLabels { - private static StaticLabels of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Action - .StaticLabels - staticLabels) { - return new DefaultStaticLabels(staticLabels.getIdsList()); - } - + private static class ConvertedStaticLabels implements StaticLabels { List ids; } @Value @Accessors(fluent = true) - private static class DefaultCondition implements Condition { - private static Condition of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition - condition) { - switch (condition.getConditionCase()) { - case LEAF_CONDITION: - return new DefaultCondition( - DefaultLeafCondition.of(condition.getLeafCondition()), - null, - ConditionType.LEAF_CONDITION); - case COMPOSITE_CONDITION: - default: - throw new IllegalArgumentException("Condition not set correctly"); - } - } - + private static class ConvertedCondition implements Condition { LeafCondition leafCondition; CompositeCondition compositeCondition; ConditionType conditionType; @@ -159,44 +318,21 @@ private static Condition of( @Value @Accessors(fluent = true) - private static class DefaultLeafCondition implements LeafCondition { - private static LeafCondition of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .LeafCondition - leafCondition) { - return new DefaultLeafCondition( - DefaultStringCondition.of(leafCondition.getKeyCondition()), - DefaultValueCondition.of(leafCondition)); - } + private static class ConvertedCompositeCondition implements CompositeCondition { + LogicalOperator operator; + List children; + } + @Value + @Accessors(fluent = true) + private static class ConvertedLeafCondition implements LeafCondition { StringCondition keyCondition; ValueCondition valueCondition; } @Value @Accessors(fluent = true) - private static class DefaultValueCondition implements ValueCondition { - private static ValueCondition of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .LeafCondition - leafCondition) { - switch (leafCondition.getConditionCase()) { - case STRING_CONDITION: - return new DefaultValueCondition( - DefaultStringCondition.of(leafCondition.getStringCondition()), - null, - ValueConditionType.STRING_CONDITION); - case UNARY_CONDITION: - return new DefaultValueCondition( - null, - DefaultUnaryCondition.of(leafCondition.getUnaryCondition()), - ValueConditionType.UNARY_CONDITION); - case JSON_CONDITION: - default: - throw new IllegalArgumentException("Invalid operator in leaf condition"); - } - } - + private static class ConvertedValueCondition implements ValueCondition { StringCondition stringCondition; UnaryCondition unaryCondition; ValueConditionType valueConditionType; @@ -204,41 +340,13 @@ private static ValueCondition of( @Value @Accessors(fluent = true) - private static class DefaultUnaryCondition implements UnaryCondition { - private static UnaryCondition of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .UnaryCondition - unaryCondition) { - switch (unaryCondition.getOperator()) { - case OPERATOR_EXISTS: - return new DefaultUnaryCondition(Operator.OPERATOR_EXISTS); - case OPERATOR_UNSPECIFIED: - default: - throw new IllegalArgumentException("Operator not set in unary condition"); - } - } - + private static class ConvertedUnaryCondition implements UnaryCondition { Operator operator; } @Value @Accessors(fluent = true) - private static class DefaultStringCondition implements StringCondition { - private static StringCondition of( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .StringCondition - stringCondition) { - switch (stringCondition.getOperator()) { - case OPERATOR_EQUALS: - return new DefaultStringCondition(Operator.OPERATOR_EQUALS, stringCondition.getValue()); - case OPERATOR_MATCHES_REGEX: - return new DefaultStringCondition( - Operator.OPERATOR_MATCHES_REGEX, stringCondition.getValue()); - default: - throw new IllegalArgumentException("String Condition operator is not set"); - } - } - + private static class ConvertedStringCondition implements StringCondition { Operator operator; String value; } From 932f27cd6ca3db0e40951f1fc313f74485d1ce82 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Fri, 29 Oct 2021 18:42:03 +0530 Subject: [PATCH 09/15] Fixing small bug --- ...lApplicationRuleDataDeserializationConfig.java | 15 +++++++++++++++ ...LabelApplicationRuleDeserializationConfig.java | 15 +++++++++++++++ .../rules/schema/shared/ValueCondition.java | 4 ++-- 3 files changed, 32 insertions(+), 2 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java index 78ba16ce..2c12cdd9 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java @@ -40,6 +40,7 @@ public List jacksonModules() { .addAbstractTypeMapping(StaticLabels.class, StaticLabelsArgument.class) .addAbstractTypeMapping(Condition.class, ConditionArgument.class) .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) + .addAbstractTypeMapping(ValueCondition.class, ValueConditionArgument.class) .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) .addAbstractTypeMapping(StringCondition.class, StringConditionArgument.class) .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); @@ -112,6 +113,20 @@ private static class LeafConditionArgument implements LeafCondition { ValueCondition valueCondition; } + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class ValueConditionArgument implements ValueCondition { + @JsonProperty(STRING_CONDITION_KEY) + StringCondition stringCondition; + + @JsonProperty(UNARY_CONDITION_KEY) + UnaryCondition unaryCondition; + + @JsonProperty(VALUE_CONDITION_TYPE_KEY) + ValueConditionType valueConditionType; + } + @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java index 0d63ad73..2602cfd7 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -41,6 +41,7 @@ public List jacksonModules() { .addAbstractTypeMapping(StaticLabels.class, StaticLabelsArgument.class) .addAbstractTypeMapping(Condition.class, ConditionArgument.class) .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) + .addAbstractTypeMapping(ValueCondition.class, ValueConditionArgument.class) .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) .addAbstractTypeMapping(StringCondition.class, StringConditionArgument.class) .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); @@ -124,6 +125,20 @@ private static class LeafConditionArgument implements LeafCondition { ValueCondition valueCondition; } + @Value + @Accessors(fluent = true) + @NoArgsConstructor(force = true) + private static class ValueConditionArgument implements ValueCondition { + @JsonProperty(STRING_CONDITION_KEY) + StringCondition stringCondition; + + @JsonProperty(UNARY_CONDITION_KEY) + UnaryCondition unaryCondition; + + @JsonProperty(VALUE_CONDITION_TYPE_KEY) + ValueConditionType valueConditionType; + } + @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java index 7e8fc53b..d72063ec 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/ValueCondition.java @@ -11,12 +11,12 @@ public interface ValueCondition { String STRING_CONDITION_KEY = "stringCondition"; String UNARY_CONDITION_KEY = "unaryCondition"; + String VALUE_CONDITION_TYPE_KEY = "valueConditionType"; @GraphQLName(ValueConditionType.TYPE_NAME) enum ValueConditionType { STRING_CONDITION, UNARY_CONDITION; - private static final String TYPE_NAME = "ValueConditionType"; } @@ -31,7 +31,7 @@ enum ValueConditionType { UnaryCondition unaryCondition(); @GraphQLField - @GraphQLName(ValueConditionType.TYPE_NAME) + @GraphQLName(VALUE_CONDITION_TYPE_KEY) @GraphQLNonNull ValueConditionType valueConditionType(); } From 6a56adb11a410c515a6f816e8cbe5765f4635c0c Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Fri, 29 Oct 2021 22:03:49 +0530 Subject: [PATCH 10/15] Simplifying schema --- .../LabelApplicationRuleRequestConverter.java | 62 +++++++----------- ...LabelApplicationRuleResponseConverter.java | 64 +++++-------------- ...licationRuleDataDeserializationConfig.java | 23 +------ ...lApplicationRuleDeserializationConfig.java | 23 +------ .../schema/shared/CompositeCondition.java | 31 --------- .../rules/schema/shared/Condition.java | 22 +------ .../shared/LabelApplicationRuleData.java | 7 +- 7 files changed, 47 insertions(+), 185 deletions(-) delete mode 100644 hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index 18c14f93..cbc7dc03 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -1,5 +1,6 @@ package org.hypertrace.graphql.label.application.rules.dao; +import java.util.List; import java.util.stream.Collectors; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleCreateRequest; import org.hypertrace.graphql.label.application.rules.request.LabelApplicationRuleDeleteRequest; @@ -48,27 +49,11 @@ private LabelApplicationRuleData convertLabelApplicationRuleData( org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData data) { return LabelApplicationRuleData.newBuilder() .setName(data.name()) - .setMatchingCondition(convertMatchingCondition(data.condition())) + .setMatchingCondition(convertConditionList(data.conditionList())) .setLabelAction(convertLabelAction(data.action())) .build(); } - private Condition convertMatchingCondition( - org.hypertrace.graphql.label.application.rules.schema.shared.Condition condition) { - switch (condition.conditionType()) { - case LEAF_CONDITION: - return Condition.newBuilder() - .setLeafCondition(convertLeafCondition(condition.leafCondition())) - .build(); - case COMPOSITE_CONDITION: - return Condition.newBuilder() - .setCompositeCondition(convertCompositeCondition(condition.compositeCondition())) - .build(); - default: - throw new IllegalArgumentException("Error when parsing matching condition"); - } - } - private void setOperationInAction( org.hypertrace.graphql.label.application.rules.schema.shared.Action action, Action.Builder actionBuilder) { @@ -105,32 +90,29 @@ private Action convertLabelAction( return actionBuilder.build(); } - CompositeCondition convertCompositeCondition( - org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition - compositeCondition) { - CompositeCondition.Builder compositeConditionBuilder = - CompositeCondition.newBuilder() - .addAllChildren( - compositeCondition.children().stream() - .map(this::convertLeafCondition) - .map( - leafCondition -> - Condition.newBuilder().setLeafCondition(leafCondition).build()) - .collect(Collectors.toList())); - switch (compositeCondition.operator()) { - case LOGICAL_OPERATOR_AND: - return compositeConditionBuilder - .setOperator(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_AND) - .build(); - case LOGICAL_OPERATOR_OR: - return compositeConditionBuilder - .setOperator(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_OR) - .build(); - default: - throw new IllegalArgumentException("Composite Condition Conversion Failed"); + Condition convertConditionList( + List conditionList) { + if (conditionList.size() == 1) { + return convertCondition(conditionList.get(0)); + } else { + List childConditions = + conditionList.stream().map(this::convertCondition).collect(Collectors.toList()); + + CompositeCondition compositeCondition = + CompositeCondition.newBuilder() + .addAllChildren(childConditions) + .setOperator(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_AND) + .build(); + return Condition.newBuilder().setCompositeCondition(compositeCondition).build(); } } + Condition convertCondition( + org.hypertrace.graphql.label.application.rules.schema.shared.Condition condition) { + LeafCondition leafCondition = convertLeafCondition(condition.leafCondition()); + return Condition.newBuilder().setLeafCondition(leafCondition).build(); + } + LeafCondition convertLeafCondition( org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition leafCondition) { LeafCondition.Builder leafConditionBuilder = diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index edb5aff8..5afb822c 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -2,6 +2,7 @@ import io.reactivex.rxjava3.core.Observable; import io.reactivex.rxjava3.core.Single; +import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; @@ -10,7 +11,6 @@ import lombok.extern.slf4j.Slf4j; import org.hypertrace.graphql.label.application.rules.schema.query.LabelApplicationRuleResultSet; import org.hypertrace.graphql.label.application.rules.schema.shared.Action; -import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; @@ -76,12 +76,12 @@ private Optional convertLabelApplicationRule( private Optional convertLabelApplicationRuleData( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData data) { Optional action = convertAction(data.getLabelAction()); - Optional condition = convertCondition(data.getMatchingCondition()); - if (condition.isEmpty() || action.isEmpty()) { + List conditionList = convertCondition(data.getMatchingCondition()); + if (conditionList.isEmpty() || action.isEmpty()) { return Optional.empty(); } return Optional.of( - new ConvertedLabelApplicationRuleData(data.getName(), condition.get(), action.get())); + new ConvertedLabelApplicationRuleData(data.getName(), conditionList, action.get())); } private Optional convertOperationInAction( @@ -131,46 +131,38 @@ private StaticLabels convertStaticLabels( return new ConvertedStaticLabels(staticLabels.getIdsList()); } - private Optional convertCondition( + private List convertCondition( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.Condition condition) { switch (condition.getConditionCase()) { case LEAF_CONDITION: - Optional leafCondition = convertLeafCondition(condition.getLeafCondition()); - return leafCondition.map( - leafCond -> - new ConvertedCondition(leafCond, null, Condition.ConditionType.LEAF_CONDITION)); + Optional convertedCondition = + convertLeafCondition(condition.getLeafCondition()).map(ConvertedCondition::new); + return convertedCondition.map(List::of).orElse(Collections.emptyList()); case COMPOSITE_CONDITION: - Optional compositeCondition = - convertCompositeCondition(condition.getCompositeCondition()); - return compositeCondition.map( - compositeCond -> - new ConvertedCondition( - null, compositeCond, Condition.ConditionType.COMPOSITE_CONDITION)); + return convertCompositeCondition(condition.getCompositeCondition()); default: log.error("Unrecognized Condition Type {}", condition.getConditionCase().name()); - return Optional.empty(); + return Collections.emptyList(); } } - private Optional convertCompositeCondition( + private List convertCompositeCondition( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData .CompositeCondition compositeCondition) { - List leafConditionList = + List leafConditionList = compositeCondition.getChildrenList().stream() .filter(this::isLeafCondition) .map(condition -> convertLeafCondition(condition.getLeafCondition())) .filter(Optional::isPresent) .map(Optional::get) + .map(ConvertedCondition::new) .collect(Collectors.toList()); if (leafConditionList.size() != compositeCondition.getChildrenList().size()) { - return Optional.empty(); + return Collections.emptyList(); } - Optional logicalOperator = - convertLogicalOperator(compositeCondition); - return logicalOperator.map( - operator -> new ConvertedCompositeCondition(operator, leafConditionList)); + return leafConditionList; } private boolean isLeafCondition( @@ -185,21 +177,6 @@ private boolean isLeafCondition( } } - private Optional convertLogicalOperator( - org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData - .CompositeCondition - compositeCondition) { - switch (compositeCondition.getOperator()) { - case LOGICAL_OPERATOR_AND: - return Optional.of(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_AND); - case LOGICAL_OPERATOR_OR: - return Optional.of(CompositeCondition.LogicalOperator.LOGICAL_OPERATOR_OR); - default: - log.error("Unrecognized Logical Operator in Composite Condition"); - return Optional.empty(); - } - } - private Optional convertLeafCondition( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData.LeafCondition leafCondition) { @@ -288,7 +265,7 @@ private static class ConvertedLabelApplicationRule implements LabelApplicationRu @Accessors(fluent = true) private static class ConvertedLabelApplicationRuleData implements LabelApplicationRuleData { String name; - Condition condition; + List conditionList; Action action; } @@ -312,15 +289,6 @@ private static class ConvertedStaticLabels implements StaticLabels { @Accessors(fluent = true) private static class ConvertedCondition implements Condition { LeafCondition leafCondition; - CompositeCondition compositeCondition; - ConditionType conditionType; - } - - @Value - @Accessors(fluent = true) - private static class ConvertedCompositeCondition implements CompositeCondition { - LogicalOperator operator; - List children; } @Value diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java index 2c12cdd9..9fa2a922 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java @@ -9,7 +9,6 @@ import lombok.experimental.Accessors; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; import org.hypertrace.graphql.label.application.rules.schema.shared.Action; -import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; import org.hypertrace.graphql.label.application.rules.schema.shared.LeafCondition; @@ -41,7 +40,6 @@ public List jacksonModules() { .addAbstractTypeMapping(Condition.class, ConditionArgument.class) .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) .addAbstractTypeMapping(ValueCondition.class, ValueConditionArgument.class) - .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) .addAbstractTypeMapping(StringCondition.class, StringConditionArgument.class) .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); } @@ -53,8 +51,8 @@ private static class LabelApplicationRuleDataArgument implements LabelApplicatio @JsonProperty(NAME_KEY) String name; - @JsonProperty(CONDITION_KEY) - Condition condition; + @JsonProperty(CONDITION_LIST_KEY) + List conditionList; @JsonProperty(ACTION_KEY) Action action; @@ -94,12 +92,6 @@ private static class StaticLabelsArgument implements StaticLabels { private static class ConditionArgument implements Condition { @JsonProperty(LEAF_CONDITION_KEY) LeafCondition leafCondition; - - @JsonProperty(COMPOSITE_CONDITION_KEY) - CompositeCondition compositeCondition; - - @JsonProperty(CONDITION_TYPE_KEY) - ConditionType conditionType; } @Value @@ -127,17 +119,6 @@ private static class ValueConditionArgument implements ValueCondition { ValueConditionType valueConditionType; } - @Value - @Accessors(fluent = true) - @NoArgsConstructor(force = true) - private static class CompositeConditionArgument implements CompositeCondition { - @JsonProperty(LOGICAL_OPERATOR_KEY) - LogicalOperator operator; - - @JsonProperty(CHILDREN_KEY) - List children; - } - @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java index 2602cfd7..71da2d3b 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -9,7 +9,6 @@ import lombok.experimental.Accessors; import org.hypertrace.core.graphql.deserialization.ArgumentDeserializationConfig; import org.hypertrace.graphql.label.application.rules.schema.shared.Action; -import org.hypertrace.graphql.label.application.rules.schema.shared.CompositeCondition; import org.hypertrace.graphql.label.application.rules.schema.shared.Condition; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRule; import org.hypertrace.graphql.label.application.rules.schema.shared.LabelApplicationRuleData; @@ -42,7 +41,6 @@ public List jacksonModules() { .addAbstractTypeMapping(Condition.class, ConditionArgument.class) .addAbstractTypeMapping(LeafCondition.class, LeafConditionArgument.class) .addAbstractTypeMapping(ValueCondition.class, ValueConditionArgument.class) - .addAbstractTypeMapping(CompositeCondition.class, CompositeConditionArgument.class) .addAbstractTypeMapping(StringCondition.class, StringConditionArgument.class) .addAbstractTypeMapping(UnaryCondition.class, UnaryConditionArgument.class)); } @@ -65,8 +63,8 @@ private static class LabelApplicationRuleDataArgument implements LabelApplicatio @JsonProperty(NAME_KEY) String name; - @JsonProperty(CONDITION_KEY) - Condition condition; + @JsonProperty(CONDITION_LIST_KEY) + List conditionList; @JsonProperty(ACTION_KEY) Action action; @@ -106,12 +104,6 @@ private static class StaticLabelsArgument implements StaticLabels { private static class ConditionArgument implements Condition { @JsonProperty(LEAF_CONDITION_KEY) LeafCondition leafCondition; - - @JsonProperty(COMPOSITE_CONDITION_KEY) - CompositeCondition compositeCondition; - - @JsonProperty(CONDITION_TYPE_KEY) - ConditionType conditionType; } @Value @@ -139,17 +131,6 @@ private static class ValueConditionArgument implements ValueCondition { ValueConditionType valueConditionType; } - @Value - @Accessors(fluent = true) - @NoArgsConstructor(force = true) - private static class CompositeConditionArgument implements CompositeCondition { - @JsonProperty(LOGICAL_OPERATOR_KEY) - LogicalOperator operator; - - @JsonProperty(CHILDREN_KEY) - List children; - } - @Value @Accessors(fluent = true) @NoArgsConstructor(force = true) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java deleted file mode 100644 index 17e77805..00000000 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/CompositeCondition.java +++ /dev/null @@ -1,31 +0,0 @@ -package org.hypertrace.graphql.label.application.rules.schema.shared; - -import graphql.annotations.annotationTypes.GraphQLField; -import graphql.annotations.annotationTypes.GraphQLName; -import graphql.annotations.annotationTypes.GraphQLNonNull; -import java.util.List; - -@GraphQLName(CompositeCondition.TYPE_NAME) -public interface CompositeCondition { - String TYPE_NAME = "LabelApplicationCompositeCondition"; - - String LOGICAL_OPERATOR_KEY = "operator"; - String CHILDREN_KEY = "children"; - - @GraphQLName(LogicalOperator.TYPE_NAME) - enum LogicalOperator { - LOGICAL_OPERATOR_AND, - LOGICAL_OPERATOR_OR; - private static final String TYPE_NAME = "LogicalOperator"; - } - - @GraphQLField - @GraphQLNonNull - @GraphQLName(LOGICAL_OPERATOR_KEY) - LogicalOperator operator(); - - @GraphQLField - @GraphQLNonNull - @GraphQLName(CHILDREN_KEY) - List children(); -} diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java index d83048a1..6a3d1b1a 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Condition.java @@ -3,35 +3,15 @@ import graphql.annotations.annotationTypes.GraphQLField; import graphql.annotations.annotationTypes.GraphQLName; import graphql.annotations.annotationTypes.GraphQLNonNull; -import javax.annotation.Nullable; @GraphQLName(Condition.TYPE_NAME) public interface Condition { String TYPE_NAME = "LabelApplicationCondition"; String LEAF_CONDITION_KEY = "leafCondition"; - String COMPOSITE_CONDITION_KEY = "compositeCondition"; - String CONDITION_TYPE_KEY = "conditionType"; - - @GraphQLName(ConditionType.TYPE_NAME) - enum ConditionType { - LEAF_CONDITION, - COMPOSITE_CONDITION; - private static final String TYPE_NAME = "ConditionType"; - } @GraphQLField @GraphQLName(LEAF_CONDITION_KEY) - @Nullable - LeafCondition leafCondition(); - - @GraphQLField - @GraphQLName(COMPOSITE_CONDITION_KEY) - @Nullable - CompositeCondition compositeCondition(); - - @GraphQLField - @GraphQLName(CONDITION_TYPE_KEY) @GraphQLNonNull - ConditionType conditionType(); + LeafCondition leafCondition(); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java index bc9be880..42b7f744 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRuleData.java @@ -3,6 +3,7 @@ import graphql.annotations.annotationTypes.GraphQLField; import graphql.annotations.annotationTypes.GraphQLName; import graphql.annotations.annotationTypes.GraphQLNonNull; +import java.util.List; @GraphQLName(LabelApplicationRuleData.TYPE_NAME) public interface LabelApplicationRuleData { @@ -10,7 +11,7 @@ public interface LabelApplicationRuleData { String ARGUMENT_NAME = "labelApplicationRuleData"; String NAME_KEY = "name"; - String CONDITION_KEY = "condition"; + String CONDITION_LIST_KEY = "conditionList"; String ACTION_KEY = "action"; @GraphQLField @@ -20,8 +21,8 @@ public interface LabelApplicationRuleData { @GraphQLField @GraphQLNonNull - @GraphQLName(CONDITION_KEY) - Condition condition(); + @GraphQLName(CONDITION_LIST_KEY) + List conditionList(); @GraphQLField @GraphQLNonNull From 459a66403598158cd9bad65d0f92b29428e0e61e Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 3 Nov 2021 12:31:58 +0530 Subject: [PATCH 11/15] Addessing PR comments --- .../LabelApplicationRuleRequestConverter.java | 35 +++++-------- ...LabelApplicationRuleResponseConverter.java | 51 ++++++------------- ...lApplicationRuleDeserializationConfig.java | 2 +- .../rules/schema/shared/Action.java | 6 +-- .../schema/shared/LabelApplicationRule.java | 9 +--- 5 files changed, 36 insertions(+), 67 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index cbc7dc03..1a94e002 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -54,42 +54,35 @@ private LabelApplicationRuleData convertLabelApplicationRuleData( .build(); } - private void setOperationInAction( - org.hypertrace.graphql.label.application.rules.schema.shared.Action action, - Action.Builder actionBuilder) { + private Action.Operation getOperationFromAction(org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { switch (action.operation()) { case OPERATION_MERGE: - actionBuilder.setOperation(Action.Operation.OPERATION_MERGE); - return; + return Action.Operation.OPERATION_MERGE; default: throw new IllegalArgumentException("Unsupported Operation"); } } - private void setLabelsInAction( - org.hypertrace.graphql.label.application.rules.schema.shared.Action action, - Action.Builder actionBuilder) { + private Action convertLabelAction( + org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { + Action.Operation operation = getOperationFromAction(action); + Action.Builder actionBuilder = + Action.newBuilder() + .setOperation(operation) + .addAllEntityTypes(action.entityTypes()); switch (action.valueType()) { case STATIC_LABELS: - actionBuilder.setStaticLabels( - Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()); - return; + return actionBuilder.setStaticLabels( + Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()) + .build(); case DYNAMIC_LABEL_KEY: - actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()).build(); - return; + return actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()) + .build(); default: throw new IllegalArgumentException("Unsupported action value"); } } - private Action convertLabelAction( - org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { - Action.Builder actionBuilder = Action.newBuilder().addAllEntityTypes(action.entityTypes()); - setOperationInAction(action, actionBuilder); - setLabelsInAction(action, actionBuilder); - return actionBuilder.build(); - } - Condition convertConditionList( List conditionList) { if (conditionList.size() == 1) { diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index 5afb822c..35c04afa 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -1,5 +1,6 @@ package org.hypertrace.graphql.label.application.rules.dao; +import io.reactivex.rxjava3.core.Maybe; import io.reactivex.rxjava3.core.Observable; import io.reactivex.rxjava3.core.Single; import java.util.Collections; @@ -27,40 +28,27 @@ class LabelApplicationRuleResponseConverter { Single convertCreateLabelApplicationRuleResponse( CreateLabelApplicationRuleResponse response) { - Optional rule = + Optional labelApplicationRule = convertLabelApplicationRule(response.getLabelApplicationRule()); - if (rule.isPresent()) { - return Single.just(rule.get()); - } else { - return Single.error(new IllegalArgumentException("Unable to convert rule create response")); - } + return labelApplicationRule.map(Single::just) + .orElse(Single.error(new IllegalArgumentException("Unable to convert rule create response"))); } Single convertGetLabelApplicationsRuleResponse( GetLabelApplicationRulesResponse response) { return Observable.fromIterable(response.getLabelApplicationRulesList()) .map(this::convertLabelApplicationRule) - .flatMapSingle( - convertedRule -> { - if (convertedRule.isEmpty()) { - return Single.error( - new IllegalArgumentException("Unable to convert a rule in get all response")); - } - return Single.just(convertedRule.get()); - }) + .flatMapMaybe(Maybe::fromOptional) .toList() .map(ConvertedLabelApplicationRuleResultSet::forRuleList); } Single convertUpdateLabelApplicationRuleResponse( UpdateLabelApplicationRuleResponse response) { - Optional rule = + Optional labelApplicationRule = convertLabelApplicationRule(response.getLabelApplicationRule()); - if (rule.isPresent()) { - return Single.just(rule.get()); - } else { - return Single.error(new IllegalArgumentException("Unable to convert rule update response")); - } + return labelApplicationRule.map(Single::just) + .orElse(Single.error(new IllegalArgumentException("Unable to convert rule update response"))); } Single buildDeleteLabelApplicationRuleResponse() { @@ -77,11 +65,10 @@ private Optional convertLabelApplicationRuleData( org.hypertrace.label.application.rule.config.service.v1.LabelApplicationRuleData data) { Optional action = convertAction(data.getLabelAction()); List conditionList = convertCondition(data.getMatchingCondition()); - if (conditionList.isEmpty() || action.isEmpty()) { + if (conditionList.isEmpty()) { return Optional.empty(); } - return Optional.of( - new ConvertedLabelApplicationRuleData(data.getName(), conditionList, action.get())); + return action.map(labelAction -> new ConvertedLabelApplicationRuleData(data.getName(), conditionList, labelAction)); } private Optional convertOperationInAction( @@ -101,20 +88,15 @@ private Optional convertAction( action) { List entityTypes = action.getEntityTypesList(); Optional operation = convertOperationInAction(action); - if (operation.isEmpty()) { - return Optional.empty(); - } switch (action.getValueCase()) { case STATIC_LABELS: StaticLabels staticLabels = convertStaticLabels(action.getStaticLabels()); - return Optional.of( - new ConvertedAction( - entityTypes, operation.get(), staticLabels, null, Action.ValueType.STATIC_LABELS)); + return operation.map(op -> + new ConvertedAction(entityTypes, op, staticLabels, null, Action.ValueType.STATIC_LABELS)); case DYNAMIC_LABEL_KEY: - return Optional.of( - new ConvertedAction( + return operation.map(op -> new ConvertedAction( entityTypes, - operation.get(), + op, null, action.getDynamicLabelKey(), Action.ValueType.STATIC_LABELS)); @@ -155,8 +137,7 @@ private List convertCompositeCondition( compositeCondition.getChildrenList().stream() .filter(this::isLeafCondition) .map(condition -> convertLeafCondition(condition.getLeafCondition())) - .filter(Optional::isPresent) - .map(Optional::get) + .flatMap(Optional::stream) .map(ConvertedCondition::new) .collect(Collectors.toList()); if (leafConditionList.size() != compositeCondition.getChildrenList().size()) { @@ -186,7 +167,7 @@ private Optional convertLeafCondition( if (keyCondition.isEmpty() || valueCondition.isEmpty()) { return Optional.empty(); } - return Optional.of(new ConvertedLeafCondition(keyCondition.get(), valueCondition.get())); + return Optional.of(new ConvertedLeafCondition(keyCondition.orElseThrow(), valueCondition.orElseThrow())); } private Optional convertValueCondition( diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java index 71da2d3b..5d9930a1 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -49,7 +49,7 @@ public List jacksonModules() { @Accessors(fluent = true) @NoArgsConstructor(force = true) private static class LabelApplicationRuleArgument implements LabelApplicationRule { - @JsonProperty(ID_KEY) + @JsonProperty(IDENTITY_FIELD_NAME) String id; @JsonProperty(LABEL_APPLICATION_RULE_DATA_KEY) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java index d8ebb299..76b888fa 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java @@ -14,19 +14,19 @@ public interface Action { String OPERATION_KEY = "operation"; String STATIC_LABELS = "staticLabels"; String DYNAMIC_LABEL_KEY_KEY = "dynamicLabelKey"; - String VALUE_TYPE_KEY = "valueType"; + String VALUE_TYPE_KEY = "actionType"; @GraphQLName(Operation.TYPE_NAME) enum Operation { OPERATION_MERGE; - private static final String TYPE_NAME = "ActionOperator"; + private static final String TYPE_NAME = "LabelApplicationActionOperator"; } @GraphQLName(ValueType.TYPE_NAME) enum ValueType { STATIC_LABELS, DYNAMIC_LABEL_KEY; - private static final String TYPE_NAME = "ValueType"; + private static final String TYPE_NAME = "LabelApplicationValueType"; } @GraphQLField diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java index 3b993a46..4ffa4010 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/LabelApplicationRule.java @@ -3,20 +3,15 @@ import graphql.annotations.annotationTypes.GraphQLField; import graphql.annotations.annotationTypes.GraphQLName; import graphql.annotations.annotationTypes.GraphQLNonNull; +import org.hypertrace.core.graphql.common.schema.id.Identifiable; @GraphQLName(LabelApplicationRule.TYPE_NAME) -public interface LabelApplicationRule { +public interface LabelApplicationRule extends Identifiable { String TYPE_NAME = "LabelApplicationRule"; String ARGUMENT_NAME = "labelApplicationRule"; - String ID_KEY = "id"; String LABEL_APPLICATION_RULE_DATA_KEY = "labelApplicationRuleData"; - @GraphQLField - @GraphQLNonNull - @GraphQLName(ID_KEY) - String id(); - @GraphQLField @GraphQLNonNull @GraphQLName(LABEL_APPLICATION_RULE_DATA_KEY) From 250e69885691696b821d01388b58017ec7ef35d6 Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 3 Nov 2021 12:33:38 +0530 Subject: [PATCH 12/15] Addessing PR comments --- .../LabelApplicationRuleRequestConverter.java | 15 ++++--- ...LabelApplicationRuleResponseConverter.java | 39 ++++++++++++------- 2 files changed, 32 insertions(+), 22 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index 1a94e002..f46da316 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -54,7 +54,8 @@ private LabelApplicationRuleData convertLabelApplicationRuleData( .build(); } - private Action.Operation getOperationFromAction(org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { + private Action.Operation getOperationFromAction( + org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { switch (action.operation()) { case OPERATION_MERGE: return Action.Operation.OPERATION_MERGE; @@ -67,17 +68,15 @@ private Action convertLabelAction( org.hypertrace.graphql.label.application.rules.schema.shared.Action action) { Action.Operation operation = getOperationFromAction(action); Action.Builder actionBuilder = - Action.newBuilder() - .setOperation(operation) - .addAllEntityTypes(action.entityTypes()); + Action.newBuilder().setOperation(operation).addAllEntityTypes(action.entityTypes()); switch (action.valueType()) { case STATIC_LABELS: - return actionBuilder.setStaticLabels( + return actionBuilder + .setStaticLabels( Action.StaticLabels.newBuilder().addAllIds(action.staticLabels().ids()).build()) - .build(); + .build(); case DYNAMIC_LABEL_KEY: - return actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()) - .build(); + return actionBuilder.setDynamicLabelKey(action.dynamicLabelKey()).build(); default: throw new IllegalArgumentException("Unsupported action value"); } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index 35c04afa..5deb5cb1 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -30,8 +30,10 @@ Single convertCreateLabelApplicationRuleResponse( CreateLabelApplicationRuleResponse response) { Optional labelApplicationRule = convertLabelApplicationRule(response.getLabelApplicationRule()); - return labelApplicationRule.map(Single::just) - .orElse(Single.error(new IllegalArgumentException("Unable to convert rule create response"))); + return labelApplicationRule + .map(Single::just) + .orElse( + Single.error(new IllegalArgumentException("Unable to convert rule create response"))); } Single convertGetLabelApplicationsRuleResponse( @@ -47,8 +49,10 @@ Single convertUpdateLabelApplicationRuleResponse( UpdateLabelApplicationRuleResponse response) { Optional labelApplicationRule = convertLabelApplicationRule(response.getLabelApplicationRule()); - return labelApplicationRule.map(Single::just) - .orElse(Single.error(new IllegalArgumentException("Unable to convert rule update response"))); + return labelApplicationRule + .map(Single::just) + .orElse( + Single.error(new IllegalArgumentException("Unable to convert rule update response"))); } Single buildDeleteLabelApplicationRuleResponse() { @@ -68,7 +72,9 @@ private Optional convertLabelApplicationRuleData( if (conditionList.isEmpty()) { return Optional.empty(); } - return action.map(labelAction -> new ConvertedLabelApplicationRuleData(data.getName(), conditionList, labelAction)); + return action.map( + labelAction -> + new ConvertedLabelApplicationRuleData(data.getName(), conditionList, labelAction)); } private Optional convertOperationInAction( @@ -91,15 +97,19 @@ private Optional convertAction( switch (action.getValueCase()) { case STATIC_LABELS: StaticLabels staticLabels = convertStaticLabels(action.getStaticLabels()); - return operation.map(op -> - new ConvertedAction(entityTypes, op, staticLabels, null, Action.ValueType.STATIC_LABELS)); + return operation.map( + op -> + new ConvertedAction( + entityTypes, op, staticLabels, null, Action.ValueType.STATIC_LABELS)); case DYNAMIC_LABEL_KEY: - return operation.map(op -> new ConvertedAction( - entityTypes, - op, - null, - action.getDynamicLabelKey(), - Action.ValueType.STATIC_LABELS)); + return operation.map( + op -> + new ConvertedAction( + entityTypes, + op, + null, + action.getDynamicLabelKey(), + Action.ValueType.STATIC_LABELS)); default: log.error("Unrecognized Value type in Action {}", action.getValueCase().name()); return Optional.empty(); @@ -167,7 +177,8 @@ private Optional convertLeafCondition( if (keyCondition.isEmpty() || valueCondition.isEmpty()) { return Optional.empty(); } - return Optional.of(new ConvertedLeafCondition(keyCondition.orElseThrow(), valueCondition.orElseThrow())); + return Optional.of( + new ConvertedLeafCondition(keyCondition.orElseThrow(), valueCondition.orElseThrow())); } private Optional convertValueCondition( From 7e606d8286a8450f8fd5dc500410c0adc0f1c13d Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 3 Nov 2021 23:16:15 +0530 Subject: [PATCH 13/15] Addressing PR comments --- .../dao/LabelApplicationRuleRequestConverter.java | 2 +- .../dao/LabelApplicationRuleResponseConverter.java | 10 +++++++--- .../LabelApplicationRuleDataDeserializationConfig.java | 2 +- .../LabelApplicationRuleDeserializationConfig.java | 2 +- .../label/application/rules/schema/shared/Action.java | 6 +++--- 5 files changed, 13 insertions(+), 9 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java index f46da316..29f6c6f8 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleRequestConverter.java @@ -69,7 +69,7 @@ private Action convertLabelAction( Action.Operation operation = getOperationFromAction(action); Action.Builder actionBuilder = Action.newBuilder().setOperation(operation).addAllEntityTypes(action.entityTypes()); - switch (action.valueType()) { + switch (action.labelApplicationActionType()) { case STATIC_LABELS: return actionBuilder .setStaticLabels( diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java index 5deb5cb1..151a1704 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/dao/LabelApplicationRuleResponseConverter.java @@ -100,7 +100,11 @@ private Optional convertAction( return operation.map( op -> new ConvertedAction( - entityTypes, op, staticLabels, null, Action.ValueType.STATIC_LABELS)); + entityTypes, + op, + staticLabels, + null, + Action.LabelApplicationActionType.STATIC_LABELS)); case DYNAMIC_LABEL_KEY: return operation.map( op -> @@ -109,7 +113,7 @@ private Optional convertAction( op, null, action.getDynamicLabelKey(), - Action.ValueType.STATIC_LABELS)); + Action.LabelApplicationActionType.STATIC_LABELS)); default: log.error("Unrecognized Value type in Action {}", action.getValueCase().name()); return Optional.empty(); @@ -268,7 +272,7 @@ private static class ConvertedAction implements Action { Operation operation; StaticLabels staticLabels; String dynamicLabelKey; - ValueType valueType; + LabelApplicationActionType labelApplicationActionType; } @Value diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java index 9fa2a922..221f3fa2 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java @@ -75,7 +75,7 @@ private static class ActionArgument implements Action { String dynamicLabelKey; @JsonProperty(VALUE_TYPE_KEY) - ValueType valueType; + LabelApplicationActionType labelApplicationActionType; } @Value diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java index 5d9930a1..5c2ac4ee 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -87,7 +87,7 @@ private static class ActionArgument implements Action { String dynamicLabelKey; @JsonProperty(VALUE_TYPE_KEY) - ValueType valueType; + LabelApplicationActionType labelApplicationActionType; } @Value diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java index 76b888fa..4346942b 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java @@ -22,8 +22,8 @@ enum Operation { private static final String TYPE_NAME = "LabelApplicationActionOperator"; } - @GraphQLName(ValueType.TYPE_NAME) - enum ValueType { + @GraphQLName(LabelApplicationActionType.TYPE_NAME) + enum LabelApplicationActionType { STATIC_LABELS, DYNAMIC_LABEL_KEY; private static final String TYPE_NAME = "LabelApplicationValueType"; @@ -52,5 +52,5 @@ enum ValueType { @GraphQLField @GraphQLNonNull @GraphQLName(VALUE_TYPE_KEY) - ValueType valueType(); + LabelApplicationActionType labelApplicationActionType(); } From d227623e54f15d5fae00e924d4eff74850fe0ada Mon Sep 17 00:00:00 2001 From: kamaleshnneerasa Date: Wed, 3 Nov 2021 23:18:02 +0530 Subject: [PATCH 14/15] Addressing PR comments --- .../LabelApplicationRuleDataDeserializationConfig.java | 2 +- .../LabelApplicationRuleDeserializationConfig.java | 2 +- .../graphql/label/application/rules/schema/shared/Action.java | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java index 221f3fa2..0874ede5 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDataDeserializationConfig.java @@ -74,7 +74,7 @@ private static class ActionArgument implements Action { @JsonProperty(DYNAMIC_LABEL_KEY_KEY) String dynamicLabelKey; - @JsonProperty(VALUE_TYPE_KEY) + @JsonProperty(LABEL_APPLICATION_ACTION_TYPE) LabelApplicationActionType labelApplicationActionType; } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java index 5c2ac4ee..d5f7807e 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/deserialization/LabelApplicationRuleDeserializationConfig.java @@ -86,7 +86,7 @@ private static class ActionArgument implements Action { @JsonProperty(DYNAMIC_LABEL_KEY_KEY) String dynamicLabelKey; - @JsonProperty(VALUE_TYPE_KEY) + @JsonProperty(LABEL_APPLICATION_ACTION_TYPE) LabelApplicationActionType labelApplicationActionType; } diff --git a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java index 4346942b..9d74322c 100644 --- a/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java +++ b/hypertrace-graphql-label-application-rules-schema/src/main/java/org/hypertrace/graphql/label/application/rules/schema/shared/Action.java @@ -14,7 +14,7 @@ public interface Action { String OPERATION_KEY = "operation"; String STATIC_LABELS = "staticLabels"; String DYNAMIC_LABEL_KEY_KEY = "dynamicLabelKey"; - String VALUE_TYPE_KEY = "actionType"; + String LABEL_APPLICATION_ACTION_TYPE = "actionType"; @GraphQLName(Operation.TYPE_NAME) enum Operation { @@ -51,6 +51,6 @@ enum LabelApplicationActionType { @GraphQLField @GraphQLNonNull - @GraphQLName(VALUE_TYPE_KEY) + @GraphQLName(LABEL_APPLICATION_ACTION_TYPE) LabelApplicationActionType labelApplicationActionType(); } From 47be40c000ff864944ab076e519aef40c1c55550 Mon Sep 17 00:00:00 2001 From: saxenakshitiz Date: Thu, 4 Nov 2021 00:14:53 +0530 Subject: [PATCH 15/15] Upgrade hypertrace-core-graphql from origin/main --- hypertrace-core-graphql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hypertrace-core-graphql b/hypertrace-core-graphql index 2edb2710..f50dca87 160000 --- a/hypertrace-core-graphql +++ b/hypertrace-core-graphql @@ -1 +1 @@ -Subproject commit 2edb2710fd8645b6a1fe3369a3308707dd435926 +Subproject commit f50dca87ddc6f4340436c2156ccbe08231274b47