/*
* 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.beam.sdk.options;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.auto.value.AutoValue;
import com.google.common.base.Defaults;
import com.google.common.base.Function;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.MutableClassToInstanceMap;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.ThreadLocalRandom;
import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;
import org.apache.beam.sdk.options.PipelineOptionsFactory.AnnotationPredicates;
import org.apache.beam.sdk.options.PipelineOptionsFactory.Registration;
import org.apache.beam.sdk.options.ValueProvider.RuntimeValueProvider;
import org.apache.beam.sdk.options.ValueProvider.StaticValueProvider;
import org.apache.beam.sdk.transforms.display.DisplayData;
import org.apache.beam.sdk.transforms.display.HasDisplayData;
import org.apache.beam.sdk.util.InstanceBuilder;
import org.apache.beam.sdk.util.common.ReflectHelpers;
/**
* Represents and {@link InvocationHandler} for a {@link Proxy}. The invocation handler uses bean
* introspection of the proxy class to store and retrieve values based off of the property name.
*
* <p>Unset properties use the {@code @Default} metadata on the getter to return values. If there
* is no {@code @Default} annotation on the getter, then a <a
* href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">default</a> as
* per the Java Language Specification for the expected return type is returned.
*
* <p>In addition to the getter/setter pairs, this proxy invocation handler supports
* {@link Object#equals(Object)}, {@link Object#hashCode()}, {@link Object#toString()} and
* {@link PipelineOptions#as(Class)}.
*/
@ThreadSafe
class ProxyInvocationHandler implements InvocationHandler {
/**
* No two instances of this class are considered equivalent hence we generate a random hash code.
*/
private final int hashCode = ThreadLocalRandom.current().nextInt();
private final Set<Class<? extends PipelineOptions>> knownInterfaces;
private final ClassToInstanceMap<PipelineOptions> interfaceToProxyCache;
private final Map<String, BoundValue> options;
private final Map<String, JsonNode> jsonOptions;
private final Map<String, String> gettersToPropertyNames;
private final Map<String, String> settersToPropertyNames;
ProxyInvocationHandler(Map<String, Object> options) {
this(bindOptions(options), Maps.<String, JsonNode>newHashMap());
}
private static Map<String, BoundValue> bindOptions(Map<String, Object> inputOptions) {
HashMap<String, BoundValue> options = Maps.newHashMap();
for (Map.Entry<String, Object> entry : inputOptions.entrySet()) {
options.put(entry.getKey(), BoundValue.fromExplicitOption(entry.getValue()));
}
return options;
}
private ProxyInvocationHandler(
Map<String, BoundValue> options, Map<String, JsonNode> jsonOptions) {
this.options = options;
this.jsonOptions = jsonOptions;
this.knownInterfaces = new HashSet<>(PipelineOptionsFactory.getRegisteredOptions());
gettersToPropertyNames = Maps.newHashMap();
settersToPropertyNames = Maps.newHashMap();
interfaceToProxyCache = MutableClassToInstanceMap.create();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
if (args == null && "toString".equals(method.getName())) {
return toString();
} else if (args != null && args.length == 1 && "equals".equals(method.getName())) {
return equals(args[0]);
} else if (args == null && "hashCode".equals(method.getName())) {
return hashCode();
} else if (args == null && "outputRuntimeOptions".equals(method.getName())) {
return outputRuntimeOptions((PipelineOptions) proxy);
} else if (args != null && "as".equals(method.getName()) && args[0] instanceof Class) {
@SuppressWarnings("unchecked")
Class<? extends PipelineOptions> clazz = (Class<? extends PipelineOptions>) args[0];
return as(clazz);
} else if (args != null && "populateDisplayData".equals(method.getName())
&& args[0] instanceof DisplayData.Builder) {
@SuppressWarnings("unchecked")
DisplayData.Builder builder = (DisplayData.Builder) args[0];
builder.delegate(new PipelineOptionsDisplayData());
return Void.TYPE;
}
String methodName = method.getName();
synchronized (this) {
if (gettersToPropertyNames.containsKey(methodName)) {
String propertyName = gettersToPropertyNames.get(methodName);
if (!options.containsKey(propertyName)) {
// Lazy bind the default to the method.
Object value = jsonOptions.containsKey(propertyName)
? getValueFromJson(propertyName, method)
: getDefault((PipelineOptions) proxy, method);
options.put(propertyName, BoundValue.fromDefault(value));
}
return options.get(propertyName).getValue();
} else if (settersToPropertyNames.containsKey(methodName)) {
options.put(settersToPropertyNames.get(methodName), BoundValue.fromExplicitOption(args[0]));
return Void.TYPE;
}
}
throw new RuntimeException("Unknown method [" + method + "] invoked with args ["
+ Arrays.toString(args) + "].");
}
/**
* Track whether options values are explicitly set, or retrieved from defaults.
*/
@AutoValue
abstract static class BoundValue {
@Nullable
abstract Object getValue();
abstract boolean isDefault();
private static BoundValue of(@Nullable Object value, boolean isDefault) {
return new AutoValue_ProxyInvocationHandler_BoundValue(value, isDefault);
}
/**
* Create a {@link BoundValue} representing an explicitly set option.
*/
static BoundValue fromExplicitOption(@Nullable Object value) {
return BoundValue.of(value, false);
}
/**
* Create a {@link BoundValue} representing a default option value.
*/
static BoundValue fromDefault(@Nullable Object value) {
return BoundValue.of(value, true);
}
}
/**
* Backing implementation for {@link PipelineOptions#as(Class)}.
*
* @param iface The interface that the returned object needs to implement.
* @return An object that implements the interface {@code <T>}.
*/
synchronized <T extends PipelineOptions> T as(Class<T> iface) {
checkNotNull(iface);
checkArgument(iface.isInterface(), "Not an interface: %s", iface);
if (!interfaceToProxyCache.containsKey(iface)) {
Registration<T> registration =
PipelineOptionsFactory.validateWellFormed(iface, knownInterfaces);
List<PropertyDescriptor> propertyDescriptors = registration.getPropertyDescriptors();
Class<T> proxyClass = registration.getProxyClass();
gettersToPropertyNames.putAll(generateGettersToPropertyNames(propertyDescriptors));
settersToPropertyNames.putAll(generateSettersToPropertyNames(propertyDescriptors));
knownInterfaces.add(iface);
interfaceToProxyCache.putInstance(iface,
InstanceBuilder.ofType(proxyClass)
.fromClass(proxyClass)
.withArg(InvocationHandler.class, this)
.build());
}
return interfaceToProxyCache.getInstance(iface);
}
/**
* Returns true if the other object is a ProxyInvocationHandler or is a Proxy object and has the
* same ProxyInvocationHandler as this.
*
* @param obj The object to compare against this.
* @return true iff the other object is a ProxyInvocationHandler or is a Proxy object and has the
* same ProxyInvocationHandler as this.
*/
@Override
public boolean equals(Object obj) {
return obj != null && ((obj instanceof ProxyInvocationHandler && this == obj)
|| (Proxy.isProxyClass(obj.getClass()) && this == Proxy.getInvocationHandler(obj)));
}
/**
* Each instance of this ProxyInvocationHandler is unique and has a random hash code.
*
* @return A hash code that was generated randomly.
*/
@Override
public int hashCode() {
return hashCode;
}
/**
* Returns a map of properties which correspond to {@link RuntimeValueProvider}.
*/
public Map<String, Map<String, Object>> outputRuntimeOptions(PipelineOptions options) {
Set<PipelineOptionSpec> optionSpecs = PipelineOptionsReflector.getOptionSpecs(knownInterfaces);
Map<String, Map<String, Object>> properties = Maps.newHashMap();
for (PipelineOptionSpec spec : optionSpecs) {
if (spec.getGetterMethod().getReturnType().equals(ValueProvider.class)) {
Object vp = invoke(options, spec.getGetterMethod(), null);
if (((ValueProvider) vp).isAccessible()) {
continue;
}
Map<String, Object> property = Maps.newHashMap();
property.put("type",
((ParameterizedType) spec.getGetterMethod()
.getGenericReturnType()).getActualTypeArguments()[0]);
properties.put(spec.getName(), property);
}
}
return properties;
}
/**
* Nested class to handle display data in order to set the display data namespace to something
* sensible.
*/
class PipelineOptionsDisplayData implements HasDisplayData {
/**
* Populate display data. See {@link HasDisplayData#populateDisplayData}. All explicitly set
* pipeline options will be added as display data.
*/
public void populateDisplayData(DisplayData.Builder builder) {
Set<PipelineOptionSpec> optionSpecs =
PipelineOptionsReflector.getOptionSpecs(knownInterfaces);
Multimap<String, PipelineOptionSpec> optionsMap = buildOptionNameToSpecMap(optionSpecs);
for (Map.Entry<String, BoundValue> option : options.entrySet()) {
BoundValue boundValue = option.getValue();
if (boundValue.isDefault()) {
continue;
}
DisplayDataValue resolved = DisplayDataValue.resolve(boundValue.getValue());
HashSet<PipelineOptionSpec> specs = new HashSet<>(optionsMap.get(option.getKey()));
for (PipelineOptionSpec optionSpec : specs) {
if (!optionSpec.shouldSerialize()) {
// Options that are excluded for serialization (i.e. those with @JsonIgnore) are also
// excluded from display data. These options are generally not useful for display.
continue;
}
builder.add(DisplayData.item(option.getKey(), resolved.getType(), resolved.getValue())
.withNamespace(optionSpec.getDefiningInterface()));
}
}
for (Map.Entry<String, JsonNode> jsonOption : jsonOptions.entrySet()) {
if (options.containsKey(jsonOption.getKey())) {
// Option overwritten since deserialization; don't re-write
continue;
}
HashSet<PipelineOptionSpec> specs = new HashSet<>(optionsMap.get(jsonOption.getKey()));
if (specs.isEmpty()) {
// No PipelineOptions interface for this key not currently loaded
builder.add(DisplayData.item(jsonOption.getKey(), jsonOption.getValue().toString())
.withNamespace(UnknownPipelineOptions.class));
continue;
}
for (PipelineOptionSpec spec : specs) {
if (!spec.shouldSerialize()) {
continue;
}
Object value = getValueFromJson(jsonOption.getKey(), spec.getGetterMethod());
DisplayDataValue resolved = DisplayDataValue.resolve(value);
builder.add(DisplayData.item(jsonOption.getKey(), resolved.getType(), resolved.getValue())
.withNamespace(spec.getDefiningInterface()));
}
}
}
}
/**
* Helper class to resolve a {@link DisplayData} type and value from {@link PipelineOptions}.
*/
@AutoValue
abstract static class DisplayDataValue {
/**
* The resolved display data value. May differ from the input to {@link #resolve(Object)}
*/
abstract Object getValue();
/** The resolved display data type. */
abstract DisplayData.Type getType();
/**
* Infer the value and {@link DisplayData.Type type} for the given
* {@link PipelineOptions} value.
*/
static DisplayDataValue resolve(@Nullable Object value) {
DisplayData.Type type = DisplayData.inferType(value);
if (type == null) {
value = displayDataString(value);
type = DisplayData.Type.STRING;
}
return new AutoValue_ProxyInvocationHandler_DisplayDataValue(value, type);
}
/**
* Safe {@link Object#toString()} wrapper to extract display data values for various types.
*/
private static String displayDataString(@Nullable Object value) {
if (value == null) {
return "";
}
if (!value.getClass().isArray()) {
return value.toString();
}
if (!value.getClass().getComponentType().isPrimitive()) {
return Arrays.deepToString((Object[]) value);
}
// At this point, we have some type of primitive array. Arrays.deepToString(..) requires an
// Object array, but will unwrap nested primitive arrays.
String wrapped = Arrays.deepToString(new Object[]{value});
return wrapped.substring(1, wrapped.length() - 1);
}
}
/**
* Marker interface used when the original {@link PipelineOptions} interface is not known at
* runtime. This can occur if {@link PipelineOptions} are deserialized from JSON.
*
* <p>Pipeline authors can ensure {@link PipelineOptions} type information is available at
* runtime by registering their {@link PipelineOptions options} interfaces. See the "Registration"
* section of {@link PipelineOptions} documentation.
*/
interface UnknownPipelineOptions extends PipelineOptions {}
/**
* Construct a mapping from an option name to its {@link PipelineOptions} interface(s)
* declarations. An option may be declared in multiple interfaces. If it is overridden in a
* type hierarchy, only the overriding interface will be included.
*/
private Multimap<String, PipelineOptionSpec> buildOptionNameToSpecMap(
Set<PipelineOptionSpec> props) {
Multimap<String, PipelineOptionSpec> optionsMap = HashMultimap.create();
for (PipelineOptionSpec prop : props) {
optionsMap.put(prop.getName(), prop);
}
// Filter out overridden options
for (Map.Entry<String, Collection<PipelineOptionSpec>> entry : optionsMap.asMap().entrySet()) {
/* Compare all interfaces for an option pairwise (iface1, iface2) to look for type
hierarchies. If one is the base-class of the other, remove it from the output and continue
iterating.
This is an N^2 operation per-option, but the number of interfaces defining an option
should always be small (usually 1). */
List<PipelineOptionSpec> specs = Lists.newArrayList(entry.getValue());
if (specs.size() < 2) {
// Only one known implementing interface, no need to check for inheritance
continue;
}
for (int i = 0; i < specs.size() - 1; i++) {
Class<?> iface1 = specs.get(i).getDefiningInterface();
for (int j = i + 1; j < specs.size(); j++) {
Class<?> iface2 = specs.get(j).getDefiningInterface();
if (iface1.isAssignableFrom(iface2)) {
optionsMap.remove(entry.getKey(), specs.get(i));
specs.remove(i);
// Removed element at current "i" index. Set iterators to re-evaluate
// new "i" element in outer loop.
i--;
j = specs.size();
} else if (iface2.isAssignableFrom(iface1)) {
optionsMap.remove(entry.getKey(), specs.get(j));
specs.remove(j);
// Removed element at current "j" index. Set iterator to re-evaluate
// new "j" element in inner-loop.
j--;
}
}
}
}
return optionsMap;
}
/**
* This will output all the currently set values. This is a relatively costly function
* as it will call {@code toString()} on each object that has been set and format
* the results in a readable format.
*
* @return A pretty printed string representation of this.
*/
@Override
public synchronized String toString() {
SortedMap<String, Object> sortedOptions = new TreeMap<>();
// Add the options that we received from deserialization
sortedOptions.putAll(jsonOptions);
// Override with any programmatically set options.
for (Map.Entry<String, BoundValue> entry : options.entrySet()) {
sortedOptions.put(entry.getKey(), entry.getValue().getValue());
}
StringBuilder b = new StringBuilder();
b.append("Current Settings:\n");
for (Map.Entry<String, Object> entry : sortedOptions.entrySet()) {
b.append(" " + entry.getKey() + ": " + entry.getValue() + "\n");
}
return b.toString();
}
/**
* Uses a Jackson {@link ObjectMapper} to attempt type conversion.
*
* @param method The method whose return type you would like to return.
* @param propertyName The name of the property that is being returned.
* @return An object matching the return type of the method passed in.
*/
private Object getValueFromJson(String propertyName, Method method) {
try {
JavaType type = PipelineOptionsFactory.MAPPER.getTypeFactory()
.constructType(method.getGenericReturnType());
JsonNode jsonNode = jsonOptions.get(propertyName);
return PipelineOptionsFactory.MAPPER.readValue(jsonNode.toString(), type);
} catch (IOException e) {
throw new RuntimeException("Unable to parse representation", e);
}
}
/**
* Returns a default value for the method based upon {@code @Default} metadata on the getter
* to return values. If there is no {@code @Default} annotation on the getter, then a <a
* href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html">default</a> as
* per the Java Language Specification for the expected return type is returned.
*
* @param proxy The proxy object for which we are attempting to get the default.
* @param method The getter method that was invoked.
* @return The default value from an {@link Default} annotation if present, otherwise a default
* value as per the Java Language Specification.
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private Object getDefault(PipelineOptions proxy, Method method) {
if (method.getReturnType().equals(RuntimeValueProvider.class)) {
throw new RuntimeException(String.format(
"Method %s should not have return type "
+ "RuntimeValueProvider, use ValueProvider instead.", method.getName()));
}
if (method.getReturnType().equals(StaticValueProvider.class)) {
throw new RuntimeException(String.format(
"Method %s should not have return type "
+ "StaticValueProvider, use ValueProvider instead.", method.getName()));
}
@Nullable Object defaultObject = null;
for (Annotation annotation : method.getAnnotations()) {
defaultObject = returnDefaultHelper(annotation, proxy, method);
if (defaultObject != null) {
break;
}
}
if (method.getReturnType().equals(ValueProvider.class)) {
String propertyName = gettersToPropertyNames.get(method.getName());
return defaultObject == null
? new RuntimeValueProvider(
method.getName(), propertyName,
(Class<? extends PipelineOptions>) method.getDeclaringClass(),
proxy.getOptionsId())
: new RuntimeValueProvider(
method.getName(), propertyName,
(Class<? extends PipelineOptions>) method.getDeclaringClass(),
defaultObject, proxy.getOptionsId());
} else if (defaultObject != null) {
return defaultObject;
}
/*
* We need to make sure that we return something appropriate for the return type. Thus we return
* a default value as defined by the JLS.
*/
return Defaults.defaultValue(method.getReturnType());
}
/**
* Helper method to return standard Default cases.
*/
@Nullable
private Object returnDefaultHelper(
Annotation annotation, PipelineOptions proxy, Method method) {
if (annotation instanceof Default.Class) {
return ((Default.Class) annotation).value();
} else if (annotation instanceof Default.String) {
return ((Default.String) annotation).value();
} else if (annotation instanceof Default.Boolean) {
return ((Default.Boolean) annotation).value();
} else if (annotation instanceof Default.Character) {
return ((Default.Character) annotation).value();
} else if (annotation instanceof Default.Byte) {
return ((Default.Byte) annotation).value();
} else if (annotation instanceof Default.Short) {
return ((Default.Short) annotation).value();
} else if (annotation instanceof Default.Integer) {
return ((Default.Integer) annotation).value();
} else if (annotation instanceof Default.Long) {
return ((Default.Long) annotation).value();
} else if (annotation instanceof Default.Float) {
return ((Default.Float) annotation).value();
} else if (annotation instanceof Default.Double) {
return ((Default.Double) annotation).value();
} else if (annotation instanceof Default.Enum) {
return Enum.valueOf((Class<Enum>) method.getReturnType(),
((Default.Enum) annotation).value());
} else if (annotation instanceof Default.InstanceFactory) {
return InstanceBuilder.ofType(((Default.InstanceFactory) annotation).value())
.build()
.create(proxy);
}
return null;
}
/**
* Returns a map from the getters method name to the name of the property based upon the passed in
* {@link PropertyDescriptor}s property descriptors.
*
* @param propertyDescriptors A list of {@link PropertyDescriptor}s to use when generating the
* map.
* @return A map of getter method name to property name.
*/
private static Map<String, String> generateGettersToPropertyNames(
List<PropertyDescriptor> propertyDescriptors) {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
for (PropertyDescriptor descriptor : propertyDescriptors) {
if (descriptor.getReadMethod() != null) {
builder.put(descriptor.getReadMethod().getName(), descriptor.getName());
}
}
return builder.build();
}
/**
* Returns a map from the setters method name to its matching getters method name based upon the
* passed in {@link PropertyDescriptor}s property descriptors.
*
* @param propertyDescriptors A list of {@link PropertyDescriptor}s to use when generating the
* map.
* @return A map of setter method name to getter method name.
*/
private static Map<String, String> generateSettersToPropertyNames(
List<PropertyDescriptor> propertyDescriptors) {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
for (PropertyDescriptor descriptor : propertyDescriptors) {
if (descriptor.getWriteMethod() != null) {
builder.put(descriptor.getWriteMethod().getName(), descriptor.getName());
}
}
return builder.build();
}
static class Serializer extends JsonSerializer<PipelineOptions> {
@Override
public void serialize(PipelineOptions value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonProcessingException {
ProxyInvocationHandler handler = (ProxyInvocationHandler) Proxy.getInvocationHandler(value);
synchronized (handler) {
// We first filter out any properties that have been modified since
// the last serialization of this PipelineOptions and then verify that
// they are all serializable.
Map<String, BoundValue> filteredOptions = Maps.newHashMap(handler.options);
removeIgnoredOptions(handler.knownInterfaces, filteredOptions);
ensureSerializable(handler.knownInterfaces, filteredOptions);
// Now we create the map of serializable options by taking the original
// set of serialized options (if any) and updating them with any properties
// instances that have been modified since the previous serialization.
Map<String, Object> serializableOptions =
Maps.<String, Object>newHashMap(handler.jsonOptions);
for (Map.Entry<String, BoundValue> entry : filteredOptions.entrySet()) {
serializableOptions.put(entry.getKey(), entry.getValue().getValue());
}
jgen.writeStartObject();
jgen.writeFieldName("options");
jgen.writeObject(serializableOptions);
List<Map<String, Object>> serializedDisplayData = Lists.newArrayList();
DisplayData displayData = DisplayData.from(value);
for (DisplayData.Item item : displayData.items()) {
@SuppressWarnings("unchecked")
Map<String, Object> serializedItem =
PipelineOptionsFactory.MAPPER.convertValue(item, Map.class);
serializedDisplayData.add(serializedItem);
}
jgen.writeFieldName("display_data");
jgen.writeObject(serializedDisplayData);
jgen.writeEndObject();
}
}
/**
* We remove all properties within the passed in options where there getter is annotated with
* {@link JsonIgnore @JsonIgnore} from the passed in options using the passed in interfaces.
*/
private void removeIgnoredOptions(
Set<Class<? extends PipelineOptions>> interfaces, Map<String, ?> options) {
// Find all the method names that are annotated with JSON ignore.
Set<String> jsonIgnoreMethodNames = FluentIterable.from(
ReflectHelpers.getClosureOfMethodsOnInterfaces(interfaces))
.filter(AnnotationPredicates.JSON_IGNORE.forMethod)
.transform(new Function<Method, String>() {
@Override
public String apply(Method input) {
return input.getName();
}
}).toSet();
// Remove all options that have the same method name as the descriptor.
for (PropertyDescriptor descriptor
: PipelineOptionsFactory.getPropertyDescriptors(interfaces)) {
if (jsonIgnoreMethodNames.contains(descriptor.getReadMethod().getName())) {
options.remove(descriptor.getName());
}
}
}
/**
* We use an {@link ObjectMapper} to verify that the passed in options are serializable
* and deserializable.
*/
private void ensureSerializable(Set<Class<? extends PipelineOptions>> interfaces,
Map<String, BoundValue> options) throws IOException {
// Construct a map from property name to the return type of the getter.
Map<String, Type> propertyToReturnType = Maps.newHashMap();
for (PropertyDescriptor descriptor
: PipelineOptionsFactory.getPropertyDescriptors(interfaces)) {
if (descriptor.getReadMethod() != null) {
propertyToReturnType.put(descriptor.getName(),
descriptor.getReadMethod().getGenericReturnType());
}
}
// Attempt to serialize and deserialize each property.
for (Map.Entry<String, BoundValue> entry : options.entrySet()) {
try {
String serializedValue =
PipelineOptionsFactory.MAPPER.writeValueAsString(entry.getValue().getValue());
JavaType type = PipelineOptionsFactory.MAPPER.getTypeFactory()
.constructType(propertyToReturnType.get(entry.getKey()));
PipelineOptionsFactory.MAPPER.readValue(serializedValue, type);
} catch (Exception e) {
throw new IOException(String.format(
"Failed to serialize and deserialize property '%s' with value '%s'",
entry.getKey(), entry.getValue().getValue()), e);
}
}
}
}
static class Deserializer extends JsonDeserializer<PipelineOptions> {
@Override
public PipelineOptions deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
ObjectNode objectNode = (ObjectNode) jp.readValueAsTree();
ObjectNode optionsNode = (ObjectNode) objectNode.get("options");
Map<String, JsonNode> fields = Maps.newHashMap();
for (Iterator<Map.Entry<String, JsonNode>> iterator = optionsNode.fields();
iterator.hasNext(); ) {
Map.Entry<String, JsonNode> field = iterator.next();
fields.put(field.getKey(), field.getValue());
}
PipelineOptions options =
new ProxyInvocationHandler(Maps.<String, BoundValue>newHashMap(), fields)
.as(PipelineOptions.class);
ValueProvider.RuntimeValueProvider.setRuntimeOptions(options);
return options;
}
}
}