private static Condition contains(Collection<Object> json, ContainsCondition.Containment containment) { if (json.isEmpty() && containment != ContainsCondition.Containment.ONLY) { // Every possible value satisfies the condition containing an empty subset return alwaysTrue(); } Set<Object> values = Sets.newLinkedHashSet(json); return new ContainsConditionImpl(values, containment); }
@Override public boolean impliesAny() { // Although there are an infinite number of conditions which satisfy all inputs we only check for the // most basic "alwaysTrue()" condition. return _condition.equals(Conditions.alwaysTrue()); }
@Override public Condition build() { if (_conditions.isEmpty()) { return Conditions.alwaysTrue(); } else if (_conditions.size() == 1) { return _conditions.iterator().next(); } else { return new AndConditionImpl(_conditions); } } }
@Override public boolean impliesAny() { // Although there are an infinite number of conditions which satisfy all inputs we only check for the // most basic "alwaysTrue()" condition. return _condition.equals(Conditions.alwaysTrue()); }
public static Condition always(boolean value) { return value ? alwaysTrue() : alwaysFalse(); }
@Provides @Singleton @DefaultJoinFilter Setting<Condition> provideDefaultJoinFilterConditionSupplier(SettingsRegistry settingsRegistry) { return settingsRegistry.register("databus.defaultJoinFilterCondition", Condition.class, Conditions.alwaysTrue()); } }
private void createDatabusReplaySubscription() { // Create a master databus replay subscription where the events expire every 50 hours (2 days + 2 hours) subscribe(_systemOwnerId, ChannelNames.getMasterReplayChannel(), Conditions.alwaysTrue(), Duration.ofDays(365), DatabusChannelConfiguration.REPLAY_TTL, false); }
private void createDatabusReplaySubscription() { // Create a master databus replay subscription where the events expire every 50 hours (2 days + 2 hours) subscribe(_systemOwnerId, ChannelNames.getMasterReplayChannel(), Conditions.alwaysTrue(), Duration.ofDays(365), DatabusChannelConfiguration.REPLAY_TTL, false); }
@Override public Condition build() { if (_alwaysTrue) { return Conditions.alwaysTrue(); } List<Condition> conditions = Lists.newArrayList(); if (_values != null) { conditions.add(Conditions.in(_values)); } if (_intrinsics != null) { for (Map.Entry<String, Collection<Condition>> entry : OrderedJson.ENTRY_COMPARATOR.immutableSortedCopy(_intrinsics.asMap().entrySet())) { conditions.add(Conditions.intrinsic(entry.getKey(), Conditions.or(entry.getValue()))); } } if (_conditions != null) { conditions.addAll(_conditions); } if (conditions.isEmpty()) { return Conditions.alwaysFalse(); } else if (conditions.size() == 1) { return conditions.get(0); } else { return new OrConditionImpl(conditions); } } }
@Override public void subscribe(String ownerId, String subscription, Condition tableFilter, Duration subscriptionTtl, Duration eventTtl, boolean includeDefaultJoinFilter) { // This call should be deprecated soon. checkLegalSubscriptionName(subscription); checkSubscriptionOwner(ownerId, subscription); checkNotNull(tableFilter, "tableFilter"); checkArgument(subscriptionTtl.compareTo(Duration.ZERO) > 0, "SubscriptionTtl must be >0"); checkArgument(eventTtl.compareTo(Duration.ZERO) > 0, "EventTtl must be >0"); SubscriptionConditionValidator.checkAllowed(tableFilter); if (includeDefaultJoinFilter) { // If the default join filter condition is set (that is, isn't "alwaysTrue()") then add it to the filter Condition defaultJoinFilterCondition = _defaultJoinFilterCondition.get(); if (!Conditions.alwaysTrue().equals(defaultJoinFilterCondition)) { if (tableFilter.equals(Conditions.alwaysTrue())) { tableFilter = defaultJoinFilterCondition; } else { tableFilter = Conditions.and(tableFilter, defaultJoinFilterCondition); } } } // except for resetting the ttl, recreating a subscription that already exists has no effect. // assume that multiple servers that manage the same subscriptions can each attempt to create // the subscription at startup. _subscriptionDao.insertSubscription(ownerId, subscription, tableFilter, subscriptionTtl, eventTtl); }
@PUT @Path ("{subscription}") @Consumes ("application/x.json-condition") @RequiresPermissions ("databus|subscribe|{subscription}") @Timed (name = "bv.emodb.databus.DatabusResource1.subscribe", absolute = true) @ApiOperation (value = "Subscribe operation.", notes = "Returns a SuccessResponse.", response = SuccessResponse.class ) public SuccessResponse subscribe(@PathParam ("subscription") String subscription, String conditionString, @QueryParam ("ttl") @DefaultValue ("86400") SecondsParam subscriptionTtl, @QueryParam ("eventTtl") @DefaultValue ("86400") SecondsParam eventTtl, @QueryParam ("ignoreSuppressedEvents") BooleanParam ignoreSuppressedEventsParam, @QueryParam ("includeDefaultJoinFilter") BooleanParam includeDefaultJoinFilterParam, @Authenticated Subject subject) { // By default, include the default join filter condition // Note: Historically this feature used to be called "ignoreSuppressedEvents". To provide backwards // compatibility both parameter names are accepted though precedence is given to the newer parameter. boolean includeDefaultJoinFilter = includeDefaultJoinFilterParam != null ? includeDefaultJoinFilterParam.get() : (ignoreSuppressedEventsParam != null ? ignoreSuppressedEventsParam.get() : true); Condition tableFilter = Conditions.alwaysTrue(); if (!conditionString.isEmpty()) { tableFilter = new ConditionParam(conditionString).get(); } _databus.subscribe(subject, subscription, tableFilter, subscriptionTtl.get(), eventTtl.get(), includeDefaultJoinFilter); return SuccessResponse.instance(); }
@Override public void subscribe(String ownerId, String subscription, Condition tableFilter, Duration subscriptionTtl, Duration eventTtl, boolean includeDefaultJoinFilter) { // This call should be deprecated soon. checkLegalSubscriptionName(subscription); checkSubscriptionOwner(ownerId, subscription); checkNotNull(tableFilter, "tableFilter"); checkArgument(subscriptionTtl.compareTo(Duration.ZERO) > 0, "SubscriptionTtl must be >0"); checkArgument(eventTtl.compareTo(Duration.ZERO) > 0, "EventTtl must be >0"); SubscriptionConditionValidator.checkAllowed(tableFilter); if (includeDefaultJoinFilter) { // If the default join filter condition is set (that is, isn't "alwaysTrue()") then add it to the filter Condition defaultJoinFilterCondition = _defaultJoinFilterCondition.get(); if (!Conditions.alwaysTrue().equals(defaultJoinFilterCondition)) { if (tableFilter.equals(Conditions.alwaysTrue())) { tableFilter = defaultJoinFilterCondition; } else { tableFilter = Conditions.and(tableFilter, defaultJoinFilterCondition); } } } // except for resetting the ttl, recreating a subscription that already exists has no effect. // assume that multiple servers that manage the same subscriptions can each attempt to create // the subscription at startup. _subscriptionDao.insertSubscription(ownerId, subscription, tableFilter, subscriptionTtl, eventTtl); }
if ("alwaysTrue".equals(token)) { checkArgCount(token, 0, parseConditionArgs(token)); return Conditions.alwaysTrue();