update

Author: Yancey0623

doc/design.md

@@ -101,7 +101,7 @@ spec:
 We hope Fluid users could represent it by the following line.
 
 ```python
-skaffold_git = fluid.Git(
+skaffold_git = fluid.git_resource(
     revision="master", 
     url="https://github.com/GoogleContainerTools/skaffold)
 ```
@@ -125,7 +125,7 @@ spec:
 We hope Fluid users could represent the above YAML file by the following line.
 
 ```python
-skaffold_image_leeroy_web = fluid.Image(
+skaffold_image_leeroy_web = fluid.image_resource(
     url="gcr.io/wangkuiyi/leeroy-web")
 ```
 
@@ -142,7 +142,7 @@ According to the [document](https://github.com/tektoncd/pipeline/blob/master/doc
 The following example from the [Tekton tutorial](https://github.com/tektoncd/pipeline/blob/master/docs/tutorial.md#task-inputs-and-outputs) takes an input resource, an output resource, and two input parameters.
 
 ```yaml
-goapiVersion: tekton.dev/v1alpha1
+apiVersion: tekton.dev/v1alpha1
 kind: Task
 metadata:
   name: build-docker-image-from-git-source
@@ -185,28 +185,30 @@ We hope Fluid users could represent it by the following Python/Fluid code.
 
 ```python
 def build_docker_image_from_git_source(
+        docker_source: "input,git",
+        built_image: "output,image",
+        path_to_dockerfile="/workspace/docker-source/Dockerfile",
+        path_to_context="/workspace/docker-source"):
+    '''Define a Tekton Task that builds a Docker image from a Git repo'''
+    couler.step(image="gcr.io/kaniko-project/executor:v0.14.0",
+               cmd=["/kaniko/executor"],
+               args=[f"--dockerfile={path_to_dockerfile}",
+                     f"--destination={built_image.url}",
+                     f"--context={path_to_context}"],
+               env={"DOCKER_CONFIG": "/tekton/home/.docker/"})
 ```
 
 ### Pipeline
 
-A Pipeline object is like function decleration.
-
-A Pipeline in Tekton defined an ordered series of Tasks. A valid Pipeline declearation
-must include a reference to at last one `Task`, for example:
-
-``` yaml
-tasks:
-  - name: build-the-image
-    taskRef:
-      name: build-push
-```
+A Pipeline object is like function declaration.
 
-The `Pipeline Tasks` in a Pipeline can be connected and run as a Directed Acyclic Graph(DAG), each of the Pipeline Tasks is a node, which can be connected with:
+A Pipeline in Tekton defined an ordered series of Tasks. A valid Pipeline declaration
+must include a reference to at last one `Task`, The `Pipeline Tasks` in a Pipeline can be connected and run as a Directed Acyclic Graph(DAG), each of the Pipeline Tasks is a node, which can be connected with:
 
 - `runAfter` clauses on the `Pipeline Tasks`.
 - `from` clauses on the `PipelineResources` needed by a `Task`.
 
-For an example `Pipeline` spec with `runAfter`:
+The following example `Pipeline` spec comes from [Tekton's Pipeline tutorial](https://github.com/tektoncd/pipeline/blob/master/docs/pipelines.md):
 
 ``` yaml
 - name: lint-repo
@@ -279,44 +281,82 @@ build-app  build-frontend
 In Python, a function is like a node of the DAG, which connected by the input
 and of output of the functions.
 
-We hope Fluid users can write the following program to express a DAG with `fluid.pipeline`:
+We hope Fluid users can write the following program to express a DAG with `fluid.pipeline` as the following code:
 
 ``` python
+
+WORKSPACE = fluid.git_resource(
+    url="https://github.com/GoogleContainerTools/skaffold",
+    revision="master")
+
+APP_IMAGE = fluid.image_resource()
+
+FRONTED_IMAGE = fluid.image_resource()
+
 @fluid.task
-def pylint():
-    fluid.step(...)
+def pylint(workspace:"input,git"):
+    fluid.step(image="ubuntu", cmd=["pylint"])
 
 @fluid.task
-def make_test():
-    fluid.step(...)
+def make_test(workspace:"input,git"):
+    fluid.step(image="ubuntu", cmd=["make"], args=["test"])
 
 @fluid.task
-def kaniko_build_app():
+def kaniko_build_app(workflow:"input,git", image:"output,image"):
     fluid.step(...)
 
 @fluid.task
-def kaniko_build_frontend():
+def kaniko_build_frontend(workflow:"input,git", image:"output,image"):
     fluid.step(...)
 
 @fluid.task
-def deploy_kubectl():
+def deploy_kubectl(my_frontend_image:"input,image", my_app_image:"input,image"):
     fluid.step(...)
 
 @fluid.pipeline
 def dag_demo():
-    lint_repo = pylint()
-    test_app = make_test()
-    build_app = kaniko_build_app().run_after(test_app)
-    build_frontend = kaniko_build_frontend().run_after(test_app)
-    deploy_all = deploy_kubectl()
-    deploy_all.inputs.my_frontend_image.from(build_app)
-    deploy_all.inputs.my_app_image.from(build_frontend)
+    lint_repo = pylint(WORKSPACE)
+    test_app = make_test(WORKSPACE)
+    build_app = kaniko_build_app(WORKSPACE, APP_IMAGE).run_after(test_app)
+    build_frontend = kaniko_build_frontend(WORKSPACE, FRONTEND_IMAGE).run_after(test_app)
+
+    deploy_all = deploy_kubectl(APP_IMAGE, FRONTEND_IMAGE)
+    deploy_all.my_frontend_image.from(build_app)
+    deploy_all.my_app_image.from(build_frontend)
 ```
 
 ### PipelineRun
 
-A PipelineRun object is like a function invocation:
+A PipelineRun object is like a function invocation.
+
+A PipelineRun object defines a call to a Pipeline. The following is a PipelineRun example from [Tekton's tutorial](https://github.com/tektoncd/pipeline/blob/master/docs/tutorial.md#creating-and-running-a-pipeline):
+
+``` yaml
+apiVersion: tekton.dev/v1beta1
+kind: PipelineRun
+metadata:
+  name: tutorial-pipeline-run-1
+spec:
+  serviceAccountName: tutorial-service
+  pipelineRef:
+    name: tutorial-pipeline
+  resources:
+    - name: source-repo
+      resourceRef:
+        name: skaffold-git
+    - name: web-image
+      resourceRef:
+        name: skaffold-image-leeroy-web
+```
+
+We hope Fluid users write the following program:
 
 ``` python
-build_pipeline()
+skaffold_git = fluid.git_resource(
+    revision="master",
+    url="https://github.com/GoogleContainerTools/skaffold")
+skaffold_image_leeroy_web = fluid.image_resource(
+    url="gcr.io/wangkuiyi/leeroy-web")
+
+tutorial(skaffold_git, skaffold_image_leeroy_web)
 ```