Skip to content

Commit 4d2343e

Browse files
rmansoorrmansoor
committed
[PDI-20383] - Adding runconfig options to be passed through pan command
1 parent 0515e87 commit 4d2343e

File tree

23 files changed

+3028
-13
lines changed

23 files changed

+3028
-13
lines changed

‎PAN_DELEGATE_IMPLEMENTATION.md‎

Lines changed: 220 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,220 @@
1+
# Pan Command Executor Delegate Pattern Implementation
2+
3+
## Overview
4+
5+
The `EnhancedPanCommandExecutor` has been updated to use the delegate pattern for transformation execution. This change centralizes the execution logic in the `PanTransformationDelegate` while maintaining backward compatibility with the existing Pan command interface.
6+
7+
## Key Changes
8+
9+
### 1. Enhanced Execute Method
10+
11+
The main `execute(Params params, String[] arguments)` method has been completely refactored to use the delegate pattern:
12+
13+
#### Before (Original PanCommandExecutor)
14+
```java
15+
public Result execute(final Params params, String[] arguments) throws Throwable {
16+
// Large monolithic method with inline execution logic
17+
// ~200+ lines of transformation loading and execution code
18+
// Mixed concerns: loading, configuration, and execution
19+
}
20+
```
21+
22+
#### After (EnhancedPanCommandExecutor with Delegate)
23+
```java
24+
@Override
25+
public Result execute(final Params params, String[] arguments) throws Throwable {
26+
// Handle special commands (repository listing, etc.)
27+
if (handleSpecialCommands(params)) {
28+
return exitWithStatus(CommandExecutorCodes.Pan.SUCCESS.getCode());
29+
}
30+
31+
// Load transformation
32+
TransMeta transMeta = loadTransformation(params);
33+
34+
// Validate transformation was loaded
35+
if (transMeta == null) {
36+
// Handle error cases
37+
}
38+
39+
// Handle parameter listing
40+
if (isEnabled(params.getListFileParams())) {
41+
// List parameters and return
42+
}
43+
44+
// Use delegate for actual execution
45+
return executeWithDelegate(transMeta, params, arguments);
46+
}
47+
```
48+
49+
### 2. Separation of Concerns
50+
51+
The new implementation separates different responsibilities:
52+
53+
#### Command Handling (`handleSpecialCommands`)
54+
- Repository listing (`--listrepos`)
55+
- Repository file/directory listing
56+
- Repository export operations
57+
58+
#### Transformation Loading (`loadTransformation`)
59+
- Repository-based loading
60+
- Filesystem-based loading
61+
- Fallback mechanisms
62+
63+
#### Delegate Execution (`executeWithDelegate`)
64+
- Repository initialization
65+
- Execution configuration creation
66+
- Delegate-based transformation execution
67+
- Result handling and cleanup
68+
69+
### 3. Delegate Integration
70+
71+
The `executeWithDelegate` method integrates with `PanTransformationDelegate`:
72+
73+
```java
74+
public Result executeWithDelegate(TransMeta transMeta, Params params, String[] arguments) throws Throwable {
75+
// Initialize repository if needed
76+
initializeRepository(params);
77+
78+
// Create execution configuration from parameters
79+
TransExecutionConfiguration executionConfiguration = createExecutionConfigurationFromParams(params);
80+
81+
// Set repository on delegate
82+
transformationDelegate.setRepository(repository);
83+
84+
// Use delegate for execution
85+
Result result = transformationDelegate.executeTransformation(transMeta, executionConfiguration, arguments);
86+
87+
// Handle result and cleanup
88+
return handleExecutionResult(result);
89+
}
90+
```
91+
92+
## Benefits of Delegate Pattern
93+
94+
### 1. **Centralized Execution Logic**
95+
- All transformation execution logic is now in `PanTransformationDelegate`
96+
- Consistent execution behavior across different contexts (UI, command-line)
97+
- Easier to maintain and test execution logic
98+
99+
### 2. **Improved Testability**
100+
- Execution logic can be tested independently via the delegate
101+
- Mock delegates can be injected for testing
102+
- Clear separation between command parsing and execution
103+
104+
### 3. **Enhanced Flexibility**
105+
- Different execution strategies can be implemented by swapping delegates
106+
- Local, remote, and clustered execution handled uniformly
107+
- Extension points and configurations centralized
108+
109+
### 4. **Better Code Organization**
110+
- Command executor focuses on parameter handling and workflow
111+
- Delegate focuses on transformation execution
112+
- Clear responsibility boundaries
113+
114+
## Execution Flow
115+
116+
```
117+
Pan Command Line
118+
↓
119+
EnhancedPanCommandExecutor.execute()
120+
↓
121+
handleSpecialCommands() → [Repository operations]
122+
↓
123+
loadTransformation() → [Load from repo/filesystem]
124+
↓
125+
executeWithDelegate()
126+
↓
127+
PanTransformationDelegate.executeTransformation()
128+
↓
129+
[Local/Remote/Clustered execution]
130+
↓
131+
Result processing and cleanup
132+
```
133+
134+
## Configuration Integration
135+
136+
The delegate pattern properly handles Pan command-line parameters:
137+
138+
### Repository Configuration
139+
- Automatic repository initialization from parameters
140+
- Connection management and cleanup
141+
- Trust user settings
142+
143+
### Execution Configuration
144+
- Log level mapping
145+
- Safe mode settings
146+
- Metrics gathering
147+
- Run configuration support
148+
149+
### Parameter Processing
150+
- Named parameter handling
151+
- Variable substitution
152+
- Parameter validation
153+
154+
## Backward Compatibility
155+
156+
The enhanced executor maintains full backward compatibility:
157+
158+
- ✅ All existing Pan command-line options supported
159+
- ✅ Same return codes and error handling
160+
- ✅ Identical output formatting and logging
161+
- ✅ Compatible with existing scripts and automation
162+
163+
## Testing
164+
165+
### Unit Tests
166+
- `EnhancedExecutorDelegateTest`: Tests delegate pattern integration
167+
- `PanIntegrationTest`: Tests overall Pan integration
168+
- Individual delegate tests for execution logic
169+
170+
### Integration Tests
171+
- Command-line parameter compatibility
172+
- Repository integration
173+
- Transformation execution scenarios
174+
175+
## Usage Examples
176+
177+
### Basic Transformation Execution
178+
```bash
179+
# Same as before - no changes to command line interface
180+
./pan.sh -file=/path/to/transformation.ktr
181+
```
182+
183+
### Repository-based Execution
184+
```bash
185+
# Repository execution uses delegate pattern internally
186+
./pan.sh -rep=MyRepo -user=admin -pass=password -trans=MyTransformation
187+
```
188+
189+
### Clustered Execution
190+
```bash
191+
# Clustered execution handled by delegate
192+
./pan.sh -file=/path/to/trans.ktr -runconfig=ClusterConfig
193+
```
194+
195+
## Future Enhancements
196+
197+
The delegate pattern enables future improvements:
198+
199+
1. **Dynamic Execution Strategies**: Runtime selection of execution methods
200+
2. **Enhanced Monitoring**: Centralized execution metrics and monitoring
201+
3. **Pluggable Executors**: Custom execution implementations
202+
4. **Advanced Configuration**: Sophisticated execution configuration options
203+
204+
## Migration Notes
205+
206+
For developers extending Pan functionality:
207+
208+
- Custom execution logic should be implemented in delegates
209+
- Parameter handling remains in command executors
210+
- Extension points are now centralized in delegates
211+
- Repository management is handled by enhanced executor
212+
213+
## Files Modified
214+
215+
1. **EnhancedPanCommandExecutor.java**: Main integration with delegate pattern
216+
2. **Pan.java**: Updated to use EnhancedPanCommandExecutor
217+
3. **Test files**: Updated for compatibility and new functionality
218+
4. **Documentation**: Added comprehensive usage and architecture guides
219+
220+
The delegate pattern implementation successfully modernizes the Pan command executor architecture while maintaining full compatibility with existing functionality.

‎PAN_INTEGRATION_SUMMARY.md‎

Lines changed: 142 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
# Pan.java Integration with EnhancedPanCommandExecutor
2+
3+
## Summary
4+
5+
This document outlines the changes made to integrate `EnhancedPanCommandExecutor` with the `Pan.java` main class, replacing the original `PanCommandExecutor`.
6+
7+
## Changes Made
8+
9+
### 1. Pan.java Updates
10+
11+
**File**: `/pentaho-kettle/engine/src/main/java/org/pentaho/di/pan/Pan.java`
12+
13+
#### Import Changes
14+
- Added import for `org.pentaho.di.pan.delegates.EnhancedPanCommandExecutor`
15+
16+
#### Field Declaration Changes
17+
```java
18+
// Before
19+
private static PanCommandExecutor commandExecutor;
20+
21+
// After
22+
private static EnhancedPanCommandExecutor commandExecutor;
23+
```
24+
25+
#### Method Changes
26+
```java
27+
// Before
28+
if ( getCommandExecutor() == null ) {
29+
setCommandExecutor( new PanCommandExecutor( PKG, log ) ); // init
30+
}
31+
32+
// After
33+
if ( getCommandExecutor() == null ) {
34+
setCommandExecutor( new EnhancedPanCommandExecutor( PKG, log ) ); // init
35+
}
36+
```
37+
38+
```java
39+
// Before
40+
protected static void configureParameters( Trans trans, NamedParams optionParams,
41+
TransMeta transMeta ) throws UnknownParamException {
42+
PanCommandExecutor.configureParameters( trans, optionParams, transMeta );
43+
}
44+
45+
// After
46+
protected static void configureParameters( Trans trans, NamedParams optionParams,
47+
TransMeta transMeta ) throws UnknownParamException {
48+
EnhancedPanCommandExecutor.configureParameters( trans, optionParams, transMeta );
49+
}
50+
```
51+
52+
```java
53+
// Before
54+
public static PanCommandExecutor getCommandExecutor() {
55+
return commandExecutor;
56+
}
57+
58+
public static void setCommandExecutor( PanCommandExecutor commandExecutor ) {
59+
Pan.commandExecutor = commandExecutor;
60+
}
61+
62+
// After
63+
public static EnhancedPanCommandExecutor getCommandExecutor() {
64+
return commandExecutor;
65+
}
66+
67+
public static void setCommandExecutor( EnhancedPanCommandExecutor commandExecutor ) {
68+
Pan.commandExecutor = commandExecutor;
69+
}
70+
```
71+
72+
### 2. Test File Updates
73+
74+
**File**: `/pentaho-kettle/engine/src/test/java/org/pentaho/di/pan/PanTest.java`
75+
76+
#### Import Changes
77+
- Added import for `org.pentaho.di.pan.delegates.EnhancedPanCommandExecutor`
78+
79+
#### Test Class Changes
80+
```java
81+
// Before
82+
private static class PanCommandExecutorForTesting extends PanCommandExecutor {
83+
84+
// After
85+
private static class PanCommandExecutorForTesting extends EnhancedPanCommandExecutor {
86+
```
87+
88+
#### Variable Declaration Changes
89+
```java
90+
// Before
91+
PanCommandExecutor testPanCommandExecutor = new PanCommandExecutorForTesting(...);
92+
93+
// After
94+
PanCommandExecutorForTesting testPanCommandExecutor = new PanCommandExecutorForTesting(...);
95+
```
96+
97+
### 3. Integration Test
98+
99+
**File**: `/pentaho-kettle/engine/src/test/java/org/pentaho/di/pan/delegates/PanIntegrationTest.java`
100+
101+
Created a new integration test to verify:
102+
- Pan properly uses EnhancedPanCommandExecutor
103+
- The transformation delegate is properly initialized
104+
- The getRepository() method is available and functional
105+
106+
## Benefits
107+
108+
1. **Enhanced Functionality**: Pan now uses the enhanced executor with delegate pattern and repository support
109+
2. **Centralized Logic**: Transformation execution logic is now centralized in `PanTransformationDelegate`
110+
3. **Repository Support**: Enhanced repository management with proper initialization and cleanup
111+
4. **Backward Compatibility**: All existing functionality is preserved while adding new capabilities
112+
5. **Improved Testability**: Better separation of concerns makes testing easier
113+
114+
## Verification
115+
116+
The changes have been verified by:
117+
1. Successful compilation of all modified files
118+
2. Proper inheritance hierarchy in test classes
119+
3. Integration test creation to verify functionality
120+
4. Maintenance of existing API compatibility
121+
122+
## Usage
123+
124+
No changes are required for existing Pan command usage. The enhanced executor is a drop-in replacement that provides:
125+
- All original PanCommandExecutor functionality
126+
- Enhanced transformation execution via PanTransformationDelegate
127+
- Repository management via getRepository() method
128+
- Better error handling and logging
129+
130+
## Files Modified
131+
132+
1. `Pan.java` - Main integration changes
133+
2. `PanTest.java` - Test class updates for compatibility
134+
3. `PanIntegrationTest.java` - New integration test (created)
135+
136+
## Dependencies
137+
138+
The integration relies on previously created classes:
139+
- `EnhancedPanCommandExecutor`
140+
- `PanTransformationDelegate`
141+
- `TransformationExecutionHelper`
142+
- Supporting utility classes and tests

‎core/src/main/java/org/pentaho/di/core/extension/KettleExtensionPoint.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ public enum KettleExtensionPoint {
5252
"Spoon initiates the execution of a trans (TransMeta)" ),
5353
SpoonTransExecutionConfiguration( "SpoonTransExecutionConfiguration",
5454
"Right before Spoon configuration of transformation to be executed takes place" ),
55-
SpoonTransBeforeStart( "SpoonTransBeforeStart", "Right before the transformation is started" ),
55+
TransBeforeStart( "TransBeforeStart", "Right before the transformation is started" ),
5656
RunConfigurationSelection( "RunConfigurationSelection", "Check when run configuration is selected" ),
5757
RunConfigurationIsRemote( "RunConfigurationIsRemote", "Check when run configuration is pointing to a remote server" ),
5858
SpoonRunConfiguration( "SpoonRunConfiguration", "Send the run configuration" ),

‎engine/src/main/java/org/pentaho/di/base/IParams.java‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -204,4 +204,9 @@ public interface IParams extends Serializable {
204204
* @return namedParams custom parameters to be passed into the executing file
205205
*/
206206
NamedParams getCustomNamedParams();
207+
208+
/**
209+
* @return runConfiguration the name of the run configuration to use
210+
*/
211+
String getRunConfiguration();
207212
}

0 commit comments

Comments
 (0)