Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.brooklyn.core.feed; import static com.google.common.base.Preconditions.checkNotNull; import org.apache.brooklyn.api.sensor.AttributeSensor; import org.apache.brooklyn.core.entity.Entities; import org.apache.brooklyn.core.sensor.Sensors; import org.apache.brooklyn.feed.http.HttpPollConfig; import org.apache.brooklyn.util.collections.MutableList; import org.apache.brooklyn.util.guava.Functionals; import org.apache.brooklyn.util.javalang.JavaClassNames; import org.apache.brooklyn.util.text.Strings; import com.google.common.base.Function; import com.google.common.base.Functions; import com.google.common.base.Objects; import com.google.common.base.Predicate; /** * Configuration for a poll, or a subscription etc, that is being added to a feed. * * @author aled */ public class FeedConfig<V, T, F extends FeedConfig<V, T, F>> { /** The onSuccess or onError functions can return this value to indicate that the sensor should not change. * @deprecated since 0.7.0 use UNCHANGED */ public static final Object UNSET = Entities.UNCHANGED; /** The onSuccess or onError functions can return this value to indicate that the sensor should not change. */ public static final Object UNCHANGED = Entities.UNCHANGED; /** The onSuccess or onError functions can return this value to indicate that the sensor value should be removed * (cf 'null', but useful in dynamic situations) */ public static final Object REMOVE = Entities.REMOVE; /** Indicates that no sensor is being used here. This sensor is suppressed, * but is useful where you want to use the feeds with custom success/exception/failure functions * which directly set multiple sensors, e.g. dynamically based on the poll response. * <p> * See {@link HttpPollConfig#forMultiple()} and its usages. * (It can work for any poll config, but conveniences have not been supplied for others.) */ public static final AttributeSensor<Void> NO_SENSOR = Sensors.newSensor(Void.class, "brooklyn.no.sensor"); private final AttributeSensor<T> sensor; private Function<? super V, T> onsuccess; private Function<? super V, T> onfailure; private Function<? super Exception, T> onexception; private Predicate<? super V> checkSuccess; private boolean suppressDuplicates; private boolean enabled = true; public FeedConfig(AttributeSensor<T> sensor) { this.sensor = checkNotNull(sensor, "sensor"); } public FeedConfig(FeedConfig<V, T, F> other) { this.sensor = other.sensor; this.onsuccess = other.onsuccess; this.onfailure = other.onfailure; this.onexception = other.onexception; this.checkSuccess = other.checkSuccess; this.suppressDuplicates = other.suppressDuplicates; this.enabled = other.enabled; } @SuppressWarnings("unchecked") protected F self() { return (F) this; } public AttributeSensor<T> getSensor() { return sensor; } public Predicate<? super V> getCheckSuccess() { return checkSuccess; } public Function<? super V, T> getOnSuccess() { return onsuccess; } public Function<? super V, T> getOnFailure() { return onfailure; } public Function<? super Exception, T> getOnException() { return onexception; } public boolean getSupressDuplicates() { return suppressDuplicates; } public boolean isEnabled() { return enabled; } /** sets the predicate used to check whether a feed run is successful */ public F checkSuccess(Predicate<? super V> val) { this.checkSuccess = checkNotNull(val, "checkSuccess"); return self(); } /** as {@link #checkSuccess(Predicate)} */ public F checkSuccess(final Function<? super V, Boolean> val) { return checkSuccess(Functionals.predicate(val)); } @SuppressWarnings("unused") /** @deprecated since 0.7.0, kept for rebind */ @Deprecated private F checkSuccessLegacy(final Function<? super V, Boolean> val) { return checkSuccess(new Predicate<V>() { @Override public boolean apply(V input) { return val.apply(input); } }); } public F onSuccess(Function<? super V, T> val) { this.onsuccess = checkNotNull(val, "onSuccess"); return self(); } public F setOnSuccess(T val) { return onSuccess(Functions.constant(val)); } /** * A failure is when the connection is fine (no exception) but the other end returns a result object V * which the feed can tell indicates a failure (e.g. HTTP code 404) */ public F onFailure(Function<? super V, T> val) { this.onfailure = checkNotNull(val, "onFailure"); return self(); } /** @see #onFailure(Function) */ public F setOnFailure(T val) { return onFailure(Functions.constant(val)); } /** * Registers a callback to be used by {@link #onSuccess(Function)} and {@link #onFailure(Function)}, * i.e. whenever a result comes back, but not in case of exceptions being thrown (ie problems communicating) */ public F onResult(Function<? super V, T> val) { onSuccess(val); return onFailure(val); } /** @see #onResult(Function) */ public F setOnResult(T val) { return onResult(Functions.constant(val)); } /** * An exception is when there is an error in the communication */ public F onException(Function<? super Exception, T> val) { this.onexception = checkNotNull(val, "onException"); return self(); } /** @see #onException(Function) */ public F setOnException(T val) { return onException(Functions.constant(val)); } /** * A convenience for indicating a behaviour to occur for both {@link #onException(Function)} * (error connecting) and {@link #onFailure(Function)} (successful communication but failure * report from remote end) */ public F onFailureOrException(Function<Object, T> val) { onFailure(val); return onException(val); } /** @see #onFailureOrException(Function) */ public F setOnFailureOrException(T val) { return onFailureOrException(Functions.constant(val)); } public F suppressDuplicates(boolean val) { suppressDuplicates = val; return self(); } /** * Whether this feed is enabled (defaulting to true). */ public F enabled(boolean val) { enabled = val; return self(); } public boolean hasSuccessHandler() { return this.onsuccess != null; } public boolean hasFailureHandler() { return this.onfailure != null; } public boolean hasExceptionHandler() { return this.onexception != null; } public boolean hasCheckSuccessHandler() { return this.checkSuccess != null; } @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(toStringBaseName()); result.append("["); boolean contents = false; Object source = toStringPollSource(); AttributeSensor<T> s = getSensor(); if (Strings.isNonBlank(Strings.toString(source))) { result.append(Strings.toUniqueString(source, 40)); if (s != null) { result.append("->"); result.append(s.getName()); } contents = true; } else if (s != null) { result.append(s.getName()); contents = true; } MutableList<Object> fields = toStringOtherFields(); if (fields != null) { for (Object field : fields) { if (Strings.isNonBlank(Strings.toString(field))) { if (contents) result.append(";"); contents = true; result.append(field); } } } result.append("]"); return result.toString(); } /** can be overridden to supply a simpler base name than the class name */ protected String toStringBaseName() { return JavaClassNames.simpleClassName(this); } /** can be overridden to supply add'l info for the {@link #toString()}; subclasses can add to the returned value */ protected MutableList<Object> toStringOtherFields() { return MutableList.<Object>of(); } /** can be overridden to supply add'l info for the {@link #toString()}, placed before the sensor with -> */ protected Object toStringPollSource() { return null; } /** all configs should supply a unique tag element, inserted into the feed */ protected String getUniqueTag() { return toString(); } /** returns fields which should be used for equality, including by default {@link #toStringOtherFields()} and {@link #toStringPollSource()}; * subclasses can add to the returned value */ protected MutableList<Object> equalsFields() { MutableList<Object> result = MutableList.of().appendIfNotNull(getSensor()) .appendIfNotNull(toStringPollSource()); for (Object field : toStringOtherFields()) result.appendIfNotNull(field); return result; } @Override public int hashCode() { int hc = super.hashCode(); for (Object f : equalsFields()) hc = Objects.hashCode(hc, f); return hc; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (!super.equals(obj)) return false; PollConfig<?, ?, ?> other = (PollConfig<?, ?, ?>) obj; if (!Objects.equal(getUniqueTag(), other.getUniqueTag())) return false; if (!Objects.equal(equalsFields(), other.equalsFields())) return false; return true; } }