Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

...

  1. To start the preview for an application: 
    Request Method and Endpoint 

    Code Block
    POST /v3/namespaces/{namespace-id}/preview
    where namespace-id is the name of the namespace
    Response will contain the CDAP generated unique preview-id which can be used further to get the preview data.

    Request body will contain the application configuration along with few additional configs for the preview section.

    Code Block
    {
        "artifact":{ 
          "name":"cdap-data-pipeline",
          "version":"3.5.0-SNAPSHOT",
          "scope":"SYSTEM"
        },
        "name":"MyPipeline",   
        "config":{
            "connections":[ 
             { 
                "from":"FTP",
                "to":"CSVParser"
             },
             { 
                "from":"CSVParser",
                "to":"Table"
             }
            ],
            "stages":[ 
             { 
                "name":"FTP",
                "plugin":{ 
                   "name":"FTP",
                   "type":"batchsource",
                   "label":"FTP",
                   "artifact":{ 
                      "name":"core-plugins",
                      "version":"1.4.0-SNAPSHOT",
                      "scope":"SYSTEM"
                   },
                   "properties":{ 
                      "referenceName":"myfile",
                      "path":"/tmp/myfile"
                   }
                },
                "outputSchema":"{\"fields\":[{\"name\":\"offset\",\"type\":\"long\"},{\"name\":\"body\",\"type\":\"string\"}]}"
             },
             { 
                "name":"MyCSVParser",
                "plugin":{ 
                   "name":"CSVParser",
                   "type":"transform",
                   "label":"CSVParser",
                   "artifact":{ 
                      "name":"transform-plugins",
                      "version":"1.4.0-SNAPSHOT",
                      "scope":"SYSTEM"
                   },
                   "properties":{ 
                      "format":"DEFAULT",
                      "schema":"{\"type\":\"record\",\"name\":\"etlSchemaBody\",\"fields\":[{\"name\":\"id\",\"type\":\"int\"},{\"name\":\"name\",\"type\":\"string\"}]}",
                      "field":"body"
                   }
                },
                "outputSchema":"{\"type\":\"record\",\"name\":\"etlSchemaBody\",\"fields\":[{\"name\":\"id\",\"type\":\"int\"},{\"name\":\"name\",\"type\":\"string\"}]}"
             },
             { 
                "name":"MyTable",
                "plugin":{ 
                   "name":"Table",
                   "type":"batchsink",
                   "label":"Table",
                   "artifact":{ 
                      "name":"core-plugins",
                      "version":"1.4.0-SNAPSHOT",
                      "scope":"SYSTEM"
                   },
                   "properties":{ 
                      "schema":"{\"type\":\"record\",\"name\":\"etlSchemaBody\",\"fields\":[{\"name\":\"id\",\"type\":\"int\"},{\"name\":\"name\",\"type\":\"string\"}]}",
                      "name":"mytable",
                      "schema.row.field":"id"
                   }
                },
                "outputSchema":"{\"type\":\"record\",\"name\":\"etlSchemaBody\",\"fields\":[{\"name\":\"id\",\"type\":\"int\"},{\"name\":\"name\",\"type\":\"string\"}]}",
                "inputSchema":[ 
                   { 
                      "name":"id",
                      "type":"int",
                      "nullable":false
                   },
                   { 
                      "name":"name",
                      "type":"string",
                      "nullable":false
                   }
                ]
             }
          ],
           "preview": {
                   "startStages": ["MyCSVParser"],
    			   "endStages": ["MyTable"],
                   "useSinks": ["MyTable"],
                   "outputs": {
    								"FTP": {
    										"numRecords": 10,
    										"data":	[
                                     			{"offset": 1, "body": "100,bob"},
                                     			{"offset": 2, "body": "200,rob"},
                                     			{"offset": 3, "body": "300,tom"}
                                  			]
    								}
    						}	
    			}
     
        }
    }

    a.  Simple pipeline

    Code Block
    Consider simple pipeline represented by following connections.
    
    (FTP)-------->(CSV Parser)-------->(Table)
     
    CASE 1: To preview the entire pipeline:
     
    "preview": {
                   "startStages": ["FTP"],
    			   "endStages": ["Table"],
                   "useSinks": ["Table"],
                   "outputs": {
    								"FTP": {
    										"numRecords": 10,
    								}
    						}	
    			}
     
    CASE 2: To preview section of the pipeline: (CSV Parser)-------->(Table)
     
    "preview": {
                   "startStages": ["CSVParser"],
    			   "endStages": ["Table"],
                   "useSinks": ["Table"],
                   "outputs": {
    								"FTP": {
    										"data":	[
                                     			{"offset": 1, "body": "100,bob"},
                                     			{"offset": 2, "body": "200,rob"},
                                     			{"offset": 3, "body": "300,tom"}
                                  			]
    								}
    
    						}	
    			}
     
    CASE 3: To preview only single stage (CSV Parser) in the pipeline:
     
    "preview": {
                   "startStages": ["CSV Parser"],
    			   "endStages": ["CSV Parser"],
                   "outputs": {
    								"FTP": {
    										"data":	[
                                     			{"offset": 1, "body": "100,bob"},
                                     			{"offset": 2, "body": "200,rob"},
                                     			{"offset": 3, "body": "300,tom"}
                                  			]
    								}
    						}	
    			}
     
    CASE 4: To verify if records are read correctly from FTP:
    "preview": {
                   "startStages": ["FTP"],
    			   "endStages": ["FTP"],
                   "outputs": {
    								"FTP": {
    									"numOfRecords": 10
    								}
    						}	
    			}
     
    CASE 5: To verify the data is getting written to Table properly:
    "preview": {
                   "startStages": ["Table"],
    			   "endStages": ["Table"],
                   "useSinks": ["Table"],
                   "outputs": {
    								"CSV Parser": {
    									"data":	[
    										{"id": 100, "name": "bob"},
    										{"id": 200, "name": "rob"},
    										{"id": 300, "name": "tom"}
    									]
    								}
    						}	
    			}

    b. Fork in the pipeline (multiple sinks)

    Code Block
    Consider the following pipeline:
     
    (S3 Source) --------->(Log Parser)--------->(Group By Aggregator)--------->(Python Evaluator)--------->(Aggregated Result)
                |
    			|
    			--------->(Javascript Transform)--------->(Raw Data)
     
    CASE 1: To preview entire pipeline
    "preview": {
                   "startStages": ["S3 Source"],
    			   "endStages": ["Aggregated Result", "Raw Data"],
                   "useSinks": ["Aggregated Result", "Raw Data"], // useSinks seem redundant as endStages is there which can control till what point the pipeline need to run
                   "outputs": {
    								"S3": {
    									"numOfRecords": 10
    								}
    						}	
    			}
     
    CASE 2: To mock the source
    "preview": {
                   "startStages": ["Log Parser", "Javascript Transform"],
    			   "endStages": ["Aggregated Result", "Raw Data"],
                   "useSinks": ["Aggregated Result", "Raw Data"],
                   "outputs": {
    								"S3": {
    									"data": [
    												"127.0.0.1 - frank [10/Oct/2000:13:55:36 -0800] GET /apache_pb.gif HTTP/1.0 200 2326",
    												"127.0.0.1 - bob [10/Oct/2000:14:55:36 -0710] GET /apache_pb.gif HTTP/1.0 200 2326",
    												"127.0.0.1 - tom [10/Oct/2000:23:55:36 -0920] GET /apache_pb.gif HTTP/1.0 200 2326"
    						 					]
    								}
    						}	
    			}
     
     
    CASE 3: To preview the section of the pipeline (Log Parser)--------->(Group By Aggregator)--------->(Python Evaluator)
    "preview": {
                   "startStages": ["Log Parser"],
    			   "endStages": ["Aggregated Result"],
                   "useSinks": ["Aggregated Result"],
                   "outputs": {
    								"S3": {
    									"data": [
    												"127.0.0.1 - frank [10/Oct/2000:13:55:36 -0800] GET /apache_pb.gif HTTP/1.0 200 2326",
    												"127.0.0.1 - bob [10/Oct/2000:14:55:36 -0710] GET /apache_pb.gif HTTP/1.0 200 2326",
    												"127.0.0.1 - tom [10/Oct/2000:23:55:36 -0920] GET /apache_pb.gif HTTP/1.0 200 2326"
    						 					]
    								}
    						}	
    			}
    
    
    
    CASE 4: To preview the single stage Python Evaluator
    "preview": {
                   "startStages": ["Python Evaluator"],
    			   "endStages": ["Python Evaluator"],
                   "outputs": {
    								"Group By Aggregator": {
    									"data": [
    												{"ip":"127.0.0.1", "counts":3},
    												{"ip":"127.0.0.2", "counts":4},
    												{"ip":"127.0.0.3", "counts":5},
    												{"ip":"127.0.0.4", "counts":6},
    						 					]
    								}
    						}	
    			}
    
    

    c. Join in the pipeline (multiple sources)

    Code Block
    Consider the following pipeline:
    (Database)--------->(Python Evaluator)--------->
               										| 
    												|------------>(Join)-------->(Projection)------->(HBase Sink)
    												|	
               (FTP)--------->(CSV Parser)--------->
     
     
    CASE 1: To preview entire pipeline
     
    "preview": {
                   "startStages": ["Database", "FTP"],
    			   "endStages": ["HBase Sink"],
    			   "useSinks": ["HBase Sink"],	
                   "outputs": {
    								"Database": {
    									"numOfRecords": 10
    								},
    								"FTP": {
    									"numOfRecords": 20
    								}
    						}	
    			}
    
    
    CASE 2: To mock both sources
    "preview": {
                   "startStages": ["Python Evaluator", "CSV Parser"],
    			   "endStages": ["HBase Sink"],
    			   "useSinks": ["HBase Sink"],	
                   "outputs": {
    								"Database": {
    									"data": [
    												{"name":"tom", "counts":3},
    												{"name":"bob", "counts":4},
    												{"name":"rob", "counts":5},
    												{"name":"milo", "counts":6},
    						 					]
    								},
    								"FTP": {
    									"data": [
    												{"offset":1, "body":"tom,100"},
    												{"offset":2, "body":"bob,200"},
    												{"offset":3, "body":"rob,300"},
    												{"offset":4, "body":"milo,400"},
    						 					]
    								}
    						}	
    			}
     
     
    CASE 3: To preview JOIN transform only
    "preview": {
                   "startStages": ["JOIN"],
    			   "endStages": ["JOIN"],
                   "outputs": {
    								"CSV Parser": {
    									"data": [
    												{"name":"tom", "id":3},
    												{"name":"bob", "id":4},
    												{"name":"rob", "id":5},
    												{"name":"milo", "id":6},
    						 					]
    								},
    								"Python Evaluator": {
    									"data": [
    												{"id":1, "last_name":"hardy"},
    												{"id":2, "last_name":"miller"},
    												{"id":3, "last_name":"brosnan"},
    												{"id":4, "last_name":"yellow"},
    						 					]
    								}
    						}	
    			}
    
    

    d. In order to preview either single transform or sink, it should have at least one incoming connection.

    Code Block
    Consider the pipeline containing only one transform which has no connections yet- 
     
    (Javascript Transform)
     
    Preview for this would fail since there is no incoming connection provided for the transform.
     
    Pipeline can be modified to add incoming connection as
     
    (CSV Parser)------------>(Javascript Transform)
     
    Now the preview configurations can be provided as
     
    "preview": {
                   "startStages": ["Javascript Transform"],
    			   "endStages": ["Javascript Transform"],
                   "outputs": {
    								"CSV Parser": {
    									"data": [
    												{"name":"tom", "id":3},
    												{"name":"bob", "id":4},
    												{"name":"rob", "id":5},
    												{"name":"milo", "id":6},
    						 					]
    								}
    						}	
    			}
    
    
    Note that we cannot solve this problem by having the different preview configuration property as "inputs" for the single stage when no connections are specified. How will this work if user just drops JOIN transform on the UI? We will not know in advance how many input connections the JOIN takes.
  2. How to specify the input data: User can specify the input data for preview by inserting the data directly in table format in UI or can upload a file containing the records.
    When the data is inserted in Table format, UI will convert the data into appropriate JSON records.
    When user decides to upload a file, he can upload the JSON file conforming to the schema of the next stage. Ideally we should allow uploading the CSV file as well, however how to interpret the data will be plugin dependent. For example consider the list of CSV records. Now for CSVParser plugin, the entire record will be treated as body however for Table sink, we will have to split the record based on comma to create multiple fields as specified by the next stage's input schema.

  3. Once the preview is started, the unique preview-id will be generated for it. The runtime information (<preview-id, STATUS) for the preview will be generated and will be stored (in-memory or disk). 

  4. Once the preview execution is complete, its runtime information will be updated with the status of the preview (COMPLETED or FAILED).

  5. To get the status of the preview
    Request Method and Endpoint

    Code Block
    GET /v3/namespaces/{namespace-id}/apps/{app-id}/previews/{preview-id}/status
    where namespace-id is the name of the namespace
          app-id is the name of the application for which preview data is to be requested
    	  preview-id is the id of the preview for which status is to be requested

    Response body will contain JSON encoded preview status and optional message if the preview failed.

    Code Block
    1. If preview is RUNNING
    {
    	"status": "RUNNING" 
    }
    
    2. If preview is COMPLETED
    {
    	"status": "COMPLETED" 
    }
    
    3. If preview application deployment FAILED
    {
    	"status": "DEPLOY_FAILED",
    	"errorMessage" "Exception message explaining the "errorMessage": "Preview failure root cause message."failure"
    }
     
    4. If preview application FAILED during execution of the stages
    {
    	"status": "RUNTIME_FAILED",
        "stages": {
    		[
    			"stage_1": {
    				"numOfInputRecords": 10,
    				"numOfOutputRecords": 10
    			},
    			"stage_2": {
    				"numOfInputRecords": 10,
    				"numOfOutputRecords": 7
    			},
    			"stage_3": {
    				"numOfInputRecords": 7,
    				"numOfOutputRecords": 4,
    				"errorMessage": "Failure reason"
    			}
    		]
    	} 
    }
  6. To get the preview data for stage:
    Request Method and Endpoint

    Code Block
    GET /v3/namespaces/{namespace-id}/apps/{app-id}/previews/{preview-id}/stages/{stage-name}
    where namespace-id is the name of the namespace
          app-id is the name of the application for which preview data is to be requested
    	  preview-id is the id of the preview for which data is to be requested
          stage-name is the unique name used to identify the stage

    Response body will contain JSON encoded input data and output data for the stage as well as input and output schema.

    Code Block
    {
    	"inputData": [
                     	{"first_name": "rob", "zipcode": 95131},
                        {"first_name": "bob", "zipcode": 95054},
                        {"first_name": "tom", "zipcode": 94306}
                     ],
    	"outputData":[
    					{"name": "rob", "zipcode": 95131, "age": 21},
                        {"name": "bob", "zipcode": 95054, "age": 22},
                        {"name": "tom", "zipcode": 94306, "age": 23}
    				 ],
    	"inputSchema": {
    						"type":"record",
    						"name":"etlSchemaBody",
    						"fields":[
    									{"name":"first_name", "type":"string"},
    									{"name":"zipcode", "type":"int"}
    								 ]
    					},
    	"outputSchema": {
    						"type":"record",
    						"name":"etlSchemaBody",
    						"fields":[
    									{"name":"name", "type":"string"},
    									{"name":"zipcode", "type":"int"},
    									{"name":"age", "type":"int"}
    								 ]
    					}  
    }
  7. To get the logs/metrics for the preview:
    Request Method and Endpoint

    Code Block
    GET /v3/namespaces/{namespace-id}/apps/{app-id}/previews/{preview-id}/logs
    GET /v3/namespaces/{namespace-id}/apps/{app-id}/previews/{preview-id}/metric
    where namespace-id is the name of the namespace
          app-id is the name of the application for which preview data is to be requested
    	  preview-id is the id of the preview for which data is to be requested

    Response would be similar to the regular app.

...