001/* 002 * Copyright (c) 2007-2017 Xplenty, 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 public static final String ENABLE_DECORATE_ACCUMULATED_TAP = "cascading.flowconnector.accumulated_tap.decorator.enable"; 048 049 AssertionLevel assertionLevel; 050 DebugLevel debugLevel; 051 String intermediateSchemeClassName; 052 String temporaryTapDecoratorClassName; 053 String checkpointTapDecoratorClassName; 054 Boolean enableDecorateAccumulatedTap; 055 056 /** 057 * Method setAssertionLevel sets the target planner {@link cascading.operation.AssertionLevel}. 058 * 059 * @param properties of type Map<Object, Object> 060 * @param assertionLevel of type AssertionLevel 061 */ 062 public static void setAssertionLevel( Map<Object, Object> properties, AssertionLevel assertionLevel ) 063 { 064 if( assertionLevel != null ) 065 properties.put( ASSERTION_LEVEL, assertionLevel.toString() ); 066 } 067 068 /** 069 * Method setDebugLevel sets the target planner {@link cascading.operation.DebugLevel}. 070 * 071 * @param properties of type Map<Object, Object> 072 * @param debugLevel of type DebugLevel 073 */ 074 public static void setDebugLevel( Map<Object, Object> properties, DebugLevel debugLevel ) 075 { 076 if( debugLevel != null ) 077 properties.put( DEBUG_LEVEL, debugLevel.toString() ); 078 } 079 080 /** 081 * Method setIntermediateSchemeClass is used for debugging. 082 * 083 * @param properties of type Map<Object, Object> 084 * @param intermediateSchemeClass of type Class 085 */ 086 public static void setIntermediateSchemeClass( Map<Object, Object> properties, Class<? extends Scheme> intermediateSchemeClass ) 087 { 088 if( intermediateSchemeClass != null ) 089 properties.put( INTERMEDIATE_SCHEME_CLASS, intermediateSchemeClass.getName() ); 090 } 091 092 /** 093 * Method setIntermediateSchemeClass is used for debugging. 094 * 095 * @param properties of type Map<Object, Object> 096 * @param intermediateSchemeClassName of type String 097 */ 098 public static void setIntermediateSchemeClass( Map<Object, Object> properties, String intermediateSchemeClassName ) 099 { 100 if( intermediateSchemeClassName != null ) 101 properties.put( INTERMEDIATE_SCHEME_CLASS, intermediateSchemeClassName ); 102 } 103 104 /** 105 * Method temporaryTapDecoratorClassName is used for wrapping a intermediate temporary Tap. 106 * 107 * @param properties of type Map<Object, Object> 108 * @param temporaryTapDecoratorClassName of type String 109 */ 110 public static void setTemporaryTapDecoratorClass( Map<Object, Object> properties, String temporaryTapDecoratorClassName ) 111 { 112 if( temporaryTapDecoratorClassName != null ) 113 properties.put( TEMPORARY_TAP_DECORATOR_CLASS, temporaryTapDecoratorClassName ); 114 } 115 116 /** 117 * Method checkpointTapDecoratorClassName is used for wrapping a checkpoint Tap. 118 * 119 * @param properties of type Map<Object, Object> 120 * @param checkpointTapDecoratorClassName of type String 121 */ 122 public static void setCheckpointTapDecoratorClass( Map<Object, Object> properties, String checkpointTapDecoratorClassName ) 123 { 124 if( checkpointTapDecoratorClassName != null ) 125 properties.put( CHECKPOINT_TAP_DECORATOR_CLASS, checkpointTapDecoratorClassName ); 126 } 127 128 /** 129 * Creates a new FlowConnectorProps instance. 130 * 131 * @return FlowConnectorProps instance 132 */ 133 public static FlowConnectorProps flowConnectorProps() 134 { 135 return new FlowConnectorProps(); 136 } 137 138 public FlowConnectorProps() 139 { 140 } 141 142 public AssertionLevel getAssertionLevel() 143 { 144 return assertionLevel; 145 } 146 147 /** 148 * Method setAssertionLevel sets the target planner {@link cascading.operation.AssertionLevel}. 149 * 150 * @param assertionLevel of type AssertionLevel 151 * @return this instance 152 */ 153 public FlowConnectorProps setAssertionLevel( AssertionLevel assertionLevel ) 154 { 155 this.assertionLevel = assertionLevel; 156 157 return this; 158 } 159 160 public DebugLevel getDebugLevel() 161 { 162 return debugLevel; 163 } 164 165 /** 166 * Method setDebugLevel sets the target planner {@link cascading.operation.DebugLevel}. 167 * 168 * @param debugLevel of type DebugLevel 169 * @return this instance 170 */ 171 public FlowConnectorProps setDebugLevel( DebugLevel debugLevel ) 172 { 173 this.debugLevel = debugLevel; 174 175 return this; 176 } 177 178 public String getIntermediateSchemeClassName() 179 { 180 return intermediateSchemeClassName; 181 } 182 183 /** 184 * Method setIntermediateSchemeClassName is used for debugging. 185 * 186 * @param intermediateSchemeClassName of type String 187 * @return this instance 188 */ 189 public FlowConnectorProps setIntermediateSchemeClassName( String intermediateSchemeClassName ) 190 { 191 this.intermediateSchemeClassName = intermediateSchemeClassName; 192 193 return this; 194 } 195 196 /** 197 * Method setIntermediateSchemeClassName is used for debugging. 198 * 199 * @param intermediateSchemeClass of type Class 200 * @return this instance 201 */ 202 public FlowConnectorProps setIntermediateSchemeClassName( Class<Scheme> intermediateSchemeClass ) 203 { 204 if( intermediateSchemeClass != null ) 205 this.intermediateSchemeClassName = intermediateSchemeClass.getName(); 206 207 return this; 208 } 209 210 public String getTemporaryTapDecoratorClassName() 211 { 212 return temporaryTapDecoratorClassName; 213 } 214 215 /** 216 * Method setTemporaryTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to 217 * wrap an intermediate temporary Tap instance internal to the Flow. 218 * 219 * @param temporaryTapDecoratorClassName of type String 220 * @return this instance 221 */ 222 public FlowConnectorProps setTemporaryTapDecoratorClassName( String temporaryTapDecoratorClassName ) 223 { 224 this.temporaryTapDecoratorClassName = temporaryTapDecoratorClassName; 225 226 return this; 227 } 228 229 /** 230 * Method setTemporaryTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to 231 * wrap an intermediate temporary Tap instance internal to the Flow. 232 * 233 * @param temporaryTapDecoratorClass of type Class 234 * @return this instance 235 */ 236 public FlowConnectorProps setTemporaryTapDecoratorClassName( Class<DecoratorTap> temporaryTapDecoratorClass ) 237 { 238 if( temporaryTapDecoratorClass != null ) 239 this.temporaryTapDecoratorClassName = temporaryTapDecoratorClass.getName(); 240 241 return this; 242 } 243 244 public String getCheckpointTapDecoratorClassName() 245 { 246 return checkpointTapDecoratorClassName; 247 } 248 249 /** 250 * Method setCheckpointTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to 251 * wrap an Checkpoint Tap instance within the Flow. 252 * 253 * @param checkpointTapDecoratorClassName of type String 254 * @return this instance 255 */ 256 public FlowConnectorProps setCheckpointTapDecoratorClassName( String checkpointTapDecoratorClassName ) 257 { 258 this.checkpointTapDecoratorClassName = checkpointTapDecoratorClassName; 259 260 return this; 261 } 262 263 /** 264 * Method setCheckpointTapDecoratorClassName sets the class of a {@link cascading.tap.DecoratorTap} to use to 265 * wrap an Checkpoint Tap instance within the Flow. 266 * 267 * @param checkpointTapDecoratorClass of type Class 268 * @return this instance 269 */ 270 public FlowConnectorProps setCheckpointTapDecoratorClassName( Class<DecoratorTap> checkpointTapDecoratorClass ) 271 { 272 if( checkpointTapDecoratorClass != null ) 273 this.checkpointTapDecoratorClassName = checkpointTapDecoratorClass.getName(); 274 275 return this; 276 } 277 278 public Boolean getEnableDecorateAccumulatedTap() 279 { 280 return enableDecorateAccumulatedTap; 281 } 282 283 /** 284 * Method setEnableDecorateAccumulatedTap, when set to {@code false}, disables the use of a DistCacheTap decorator 285 * implementation during planning. It is enabled by default. 286 * <p> 287 * When enabled, any {@link cascading.tap.Tap} instance declared or planned via the planner (intermediate Tap or binding 288 * a {@link cascading.pipe.Checkpoint} pipe to a tap -- when applicable) will be wrapped by a platform specific 289 * implementation of a Tap that allows for data reads from the platform provided distributed caches or similiar 290 * service, if any. 291 * 292 * @param enableDecorateAccumulatedTap the enableDecorateAccumulatedTap of type boolean 293 * @return FlowConnectorProps 294 */ 295 public FlowConnectorProps setEnableDecorateAccumulatedTap( boolean enableDecorateAccumulatedTap ) 296 { 297 this.enableDecorateAccumulatedTap = enableDecorateAccumulatedTap; 298 299 return this; 300 } 301 302 @Override 303 protected void addPropertiesTo( Properties properties ) 304 { 305 setAssertionLevel( properties, assertionLevel ); 306 setDebugLevel( properties, debugLevel ); 307 setIntermediateSchemeClass( properties, intermediateSchemeClassName ); 308 setTemporaryTapDecoratorClass( properties, temporaryTapDecoratorClassName ); 309 setCheckpointTapDecoratorClass( properties, checkpointTapDecoratorClassName ); 310 311 if( enableDecorateAccumulatedTap != null ) 312 properties.setProperty( ENABLE_DECORATE_ACCUMULATED_TAP, enableDecorateAccumulatedTap.toString() ); 313 } 314 }