/** * This method performs the transformation of the * {@link #placementConstraint}. * * @return the transformed placement constraint. */ public PlacementConstraint transform() { AbstractConstraint constraintExpr = placementConstraint.getConstraintExpr(); // Visit the constraint tree to perform the transformation. constraintExpr = constraintExpr.accept(this); return new PlacementConstraint(constraintExpr); }
public PlacementConstraintProto convert() { return (PlacementConstraintProto) placementConstraint.getConstraintExpr() .accept(this); }
/** * A disjunction of constraints. * * @param children the children constraints, one of which should be satisfied * @return the resulting placement constraint */ public static Or or(AbstractConstraint... children) { return new Or(children); }
@Override public AbstractConstraint visit(SingleConstraint constraint) { AbstractConstraint transformedConstraint = constraint; // Check if it is a target constraint. if (constraint.getMinCardinality() == 1 && constraint.getMaxCardinality() == Integer.MAX_VALUE) { transformedConstraint = new TargetConstraint(TargetOperator.IN, constraint.getScope(), constraint.getTargetExpressions()); } else if (constraint.getMinCardinality() == 0 && constraint.getMaxCardinality() == 0) { transformedConstraint = new TargetConstraint(TargetOperator.NOT_IN, constraint.getScope(), constraint.getTargetExpressions()); } return transformedConstraint; } }
@Test public void testTargetCardinalityConstraint() { AbstractConstraint constraintExpr = targetCardinality(RACK, 3, 10, allocationTag("zk")); Assert.assertTrue(constraintExpr instanceof SingleConstraint); PlacementConstraint constraint = PlacementConstraints.build(constraintExpr); // Apply transformation. Should be a no-op. SpecializedConstraintTransformer specTransformer = new SpecializedConstraintTransformer(constraint); PlacementConstraint newConstraint = specTransformer.transform(); // The constraint expression should be the same. Assert.assertEquals(constraintExpr, newConstraint.getConstraintExpr()); }
@Override public AbstractConstraint visit(CardinalityConstraint constraint) { return new SingleConstraint(constraint.getScope(), constraint.getMinCardinality(), constraint.getMaxCardinality(), new TargetExpression(TargetExpression.TargetType.ALLOCATION_TAG, AllocationTagNamespaceType.SELF.toString(), constraint.getAllocationTags())); } }
@Override public AbstractConstraint visit(DelayedOr constraint) { constraint.getChildren().forEach( child -> child.setConstraint(child.getConstraint().accept(this))); return constraint; }
/** * Creates a {@link PlacementConstraint} given a constraint expression. * * @param constraintExpr the constraint expression * @return the placement constraint */ public static PlacementConstraint build(AbstractConstraint constraintExpr) { return constraintExpr.build(); } }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); } }
/** * Creates a composite constraint that includes a list of timed placement * constraints. The scheduler should try to satisfy first the first timed * child constraint within the specified time window. If this is not possible, * it should attempt to satisfy the second, and so on. * * @param children the timed children constraints * @return the resulting composite constraint */ public static DelayedOr delayedOr(TimedPlacementConstraint... children) { return new DelayedOr(children); }
/** * A conjunction of constraints. * * @param children the children constraints that should all be satisfied * @return the resulting placement constraint */ public static And and(AbstractConstraint... children) { return new And(children); }
@Override public AbstractConstraint visit(And constraint) { return visitAndOr(constraint); }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); } }
@Override public AbstractConstraint visit(Or constraint) { return visitAndOr(constraint); }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); } }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); }
@Override public <T> T accept(Visitor<T> visitor) { return visitor.visit(this); }