    001/*
    002 * Copyright (c) 2007-2016 Concurrent, Inc. All Rights Reserved.
    003 *
    004 * Project and contact information: http://www.cascading.org/
    005 *
    006 * This file is part of the Cascading project.
    007 *
    008 * Licensed under the Apache License, Version 2.0 (the "License");
    009 * you may not use this file except in compliance with the License.
    010 * You may obtain a copy of the License at
    011 *
    012 *     http://www.apache.org/licenses/LICENSE-2.0
    013 *
    014 * Unless required by applicable law or agreed to in writing, software
    015 * distributed under the License is distributed on an "AS IS" BASIS,
    016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    017 * See the License for the specific language governing permissions and
    018 * limitations under the License.
    019 */
    020
    021package cascading.flow;
    022
    023import java.util.Map;
    024import java.util.Properties;
    025
    026import cascading.operation.AssertionLevel;
    027import cascading.operation.DebugLevel;
    028import cascading.property.Props;
    029import cascading.scheme.Scheme;
    030import cascading.tap.DecoratorTap;
    031
    032/**
    033 * The class FlowConnectorProps is a fluent helper class for setting {@link FlowConnector} specific
    034 * properties through the {@link FlowConnector} constructor.
    035 *
    036 * @see cascading.property.AppProps
    037 * @see cascading.cascade.CascadeProps
    038 * @see FlowProps
    039 */
    040public class FlowConnectorProps extends Props
    041  {
    042  public static final String ASSERTION_LEVEL = "cascading.flowconnector.assertionlevel";
    043  public static final String DEBUG_LEVEL = "cascading.flowconnector.debuglevel";
    044  public static final String INTERMEDIATE_SCHEME_CLASS = "cascading.flowconnector.intermediateschemeclass";
    045  public static final String TEMPORARY_TAP_DECORATOR_CLASS = "cascading.flowconnector.temporary_tap.decorator.classname";
    046  public static final String CHECKPOINT_TAP_DECORATOR_CLASS = "cascading.flowconnector.checkpoint_tap.decorator.classname";
    047
    048  AssertionLevel assertionLevel;
    049  DebugLevel debugLevel;
    050  String intermediateSchemeClassName;
    051  String temporaryTapDecoratorClassName;
    052  String checkpointTapDecoratorClassName;
    053
    054  /**
    055   * Method setAssertionLevel sets the target planner {@link cascading.operation.AssertionLevel}.
    056   *
    057   * @param properties     of type Map<Object, Object>
    058   * @param assertionLevel of type AssertionLevel
    059   */
    060  public static void setAssertionLevel( Map<Object, Object> properties, AssertionLevel assertionLevel )
    061    {
    062    if( assertionLevel != null )
    063      properties.put( ASSERTION_LEVEL, assertionLevel.toString() );
    064    }
    065
    066  /**
    067   * Method setDebugLevel sets the target planner {@link cascading.operation.DebugLevel}.
    068   *
    069   * @param properties of type Map<Object, Object>
    070   * @param debugLevel of type DebugLevel
    071   */
    072  public static void setDebugLevel( Map<Object, Object> properties, DebugLevel debugLevel )
    073    {
    074    if( debugLevel != null )
    075      properties.put( DEBUG_LEVEL, debugLevel.toString() );
    076    }
    077
    078  /**
    079   * Method setIntermediateSchemeClass is used for debugging.
    080   *
    081   * @param properties              of type Map<Object, Object>
    082   * @param intermediateSchemeClass of type Class
    083   */
    084  public static void setIntermediateSchemeClass( Map<Object, Object> properties, Class<? extends Scheme> intermediateSchemeClass )
    085    {
    086    if( intermediateSchemeClass != null )
    087      properties.put( INTERMEDIATE_SCHEME_CLASS, intermediateSchemeClass.getName() );
    088    }
    089
    090  /**
    091   * Method setIntermediateSchemeClass is used for debugging.
    092   *
    093   * @param properties                  of type Map<Object, Object>
    094   * @param intermediateSchemeClassName of type String
    095   */
    096  public static void setIntermediateSchemeClass( Map<Object, Object> properties, String intermediateSchemeClassName )
    097    {
    098    if( intermediateSchemeClassName != null )
    099      properties.put( INTERMEDIATE_SCHEME_CLASS, intermediateSchemeClassName );
    100    }
    101
    102  /**
    103   * Method temporaryTapDecoratorClassName is used for wrapping a intermediate temporary Tap.
    104   *
    105   * @param properties                     of type Map<Object, Object>
    106   * @param temporaryTapDecoratorClassName of type String
    107   */
    108  public static void setTemporaryTapDecoratorClass( Map<Object, Object> properties, String temporaryTapDecoratorClassName )
    109    {
    110    if( temporaryTapDecoratorClassName != null )
    111      properties.put( TEMPORARY_TAP_DECORATOR_CLASS, temporaryTapDecoratorClassName );
    112    }
    113
    114  /**
    115   * Method checkpointTapDecoratorClassName is used for wrapping a checkpoint Tap.
    116   *
    117   * @param properties                      of type Map<Object, Object>
    118   * @param checkpointTapDecoratorClassName of type String
    119   */
    120  public static void setCheckpointTapDecoratorClass( Map<Object, Object> properties, String checkpointTapDecoratorClassName )
    121    {
    122    if( checkpointTapDecoratorClassName != null )
    123      properties.put( CHECKPOINT_TAP_DECORATOR_CLASS, checkpointTapDecoratorClassName );
    124    }
    125
    126  /**
    127   * Creates a new FlowConnectorProps instance.
    128   *
    129   * @return FlowConnectorProps instance
    130   */
    131  public static FlowConnectorProps flowConnectorProps()
    132    {
    133    return new FlowConnectorProps();
    134    }
    135
    136  public FlowConnectorProps()
    137    {
    138    }
    139
    140  public AssertionLevel getAssertionLevel()
    141    {
    142    return assertionLevel;
    143    }
    144
    145  /**
    146   * Method setAssertionLevel sets the target planner {@link cascading.operation.AssertionLevel}.
    147   *
    148   * @param assertionLevel of type AssertionLevel
    149   * @return this instance
    150   */
    151  public FlowConnectorProps setAssertionLevel( AssertionLevel assertionLevel )
    152    {
    153    this.assertionLevel = assertionLevel;
    154
    155    return this;
    156    }
    157
    158  public DebugLevel getDebugLevel()
    159    {
    160    return debugLevel;
    161    }
    162
    163  /**
    164   * Method setDebugLevel sets the target planner {@link cascading.operation.DebugLevel}.
    165   *
    166   * @param debugLevel of type DebugLevel
    167   * @return this instance
    168   */
    169  public FlowConnectorProps setDebugLevel( DebugLevel debugLevel )
    170    {
    171    this.debugLevel = debugLevel;
    172
    173    return this;
    174    }
    175
    176  public String getIntermediateSchemeClassName()
    177    {
    178    return intermediateSchemeClassName;
    179    }
    180
    181  /**
    182   * Method setIntermediateSchemeClassName is used for debugging.
    183   *
    184   * @param intermediateSchemeClassName of type String
    185   * @return this instance
    186   */
    187  public FlowConnectorProps setIntermediateSchemeClassName( String intermediateSchemeClassName )
    188    {
    189    this.intermediateSchemeClassName = intermediateSchemeClassName;
    190
    191    return this;
    192    }
    193
    194  /**
    195   * Method setIntermediateSchemeClassName is used for debugging.
    196   *
    197   * @param intermediateSchemeClass of type Class
    198   * @return this instance
    199   */
    200  public FlowConnectorProps setIntermediateSchemeClassName( Class<Scheme> intermediateSchemeClass )
    201    {
    202    if( intermediateSchemeClass != null )
    203      this.intermediateSchemeClassName = intermediateSchemeClass.getName();
    204
    205    return this;
    206    }
    207
    208  public String getTemporaryTapDecoratorClassName()
    209    {
    210    return temporaryTapDecoratorClassName;
    211    }
    212
    213  /**
    214   * Method setTemporaryTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to
    215   * wrap an intermediate temporary Tap instance internal to the Flow.
    216   *
    217   * @param temporaryTapDecoratorClassName of type String
    218   * @return this instance
    219   */
    220  public FlowConnectorProps setTemporaryTapDecoratorClassName( String temporaryTapDecoratorClassName )
    221    {
    222    this.temporaryTapDecoratorClassName = temporaryTapDecoratorClassName;
    223
    224    return this;
    225    }
    226
    227  /**
    228   * Method setTemporaryTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to
    229   * wrap an intermediate temporary Tap instance internal to the Flow.
    230   *
    231   * @param temporaryTapDecoratorClass of type Class
    232   * @return this instance
    233   */
    234  public FlowConnectorProps setTemporaryTapDecoratorClassName( Class<DecoratorTap> temporaryTapDecoratorClass )
    235    {
    236    if( temporaryTapDecoratorClass != null )
    237      this.temporaryTapDecoratorClassName = temporaryTapDecoratorClass.getName();
    238
    239    return this;
    240    }
    241
    242  public String getCheckpointTapDecoratorClassName()
    243    {
    244    return checkpointTapDecoratorClassName;
    245    }
    246
    247  /**
    248   * Method setCheckpointTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to
    249   * wrap an Checkpoint Tap instance within the Flow.
    250   *
    251   * @param checkpointTapDecoratorClassName of type String
    252   * @return this instance
    253   */
    254  public FlowConnectorProps setCheckpointTapDecoratorClassName( String checkpointTapDecoratorClassName )
    255    {
    256    this.checkpointTapDecoratorClassName = checkpointTapDecoratorClassName;
    257
    258    return this;
    259    }
    260
    261  /**
    262   * Method setCheckpointTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to
    263   * wrap an Checkpoint Tap instance within the Flow.
    264   *
    265   * @param checkpointTapDecoratorClass of type Class
    266   * @return this instance
    267   */
    268  public FlowConnectorProps setCheckpointTapDecoratorClassName( Class<DecoratorTap> checkpointTapDecoratorClass )
    269    {
    270    if( checkpointTapDecoratorClass != null )
    271      this.checkpointTapDecoratorClassName = checkpointTapDecoratorClass.getName();
    272
    273    return this;
    274    }
    275
    276  @Override
    277  protected void addPropertiesTo( Properties properties )
    278    {
    279    setAssertionLevel( properties, assertionLevel );
    280    setDebugLevel( properties, debugLevel );
    281    setIntermediateSchemeClass( properties, intermediateSchemeClassName );
    282    setTemporaryTapDecoratorClass( properties, temporaryTapDecoratorClassName );
    283    setCheckpointTapDecoratorClass( properties, checkpointTapDecoratorClassName );
    284    }
    285  }