github.com/upcmd/up@v0.8.1-0.20230108151705-ad8b797bf04f/tests/functests/p0152.yml

doc_meta: |
  folder: user-interaction
  title: chained pipein from stdin
  head: |
    You can use UPcmd to chain the command output as input and choose a task to handle the data processing

  sections:
    - title: Demo
      content: |
        ```
          ▶ which uptestx
          uptestx () {
            up ngo task -d ./tests/functests -t c0152.yml --configdir=./tests/functests
          }

          ▶ curl -X GET "http://httpbin.org/get" -H "accept: application/json" |uptestx c0152
            % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
            Dload  Upload   Total   Spent    Left  Speed
            100   268  100   268    0     0    456      0 --:--:-- --:--:-- --:--:--   455
          loading [Config]:  ./tests/functests/upconfig.yml
          Main config:
            Version -> 1.0.0
            RefDir -> ./tests/functests
            WorkDir -> cwd
            AbsWorkDir -> /up-project/up
            TaskFile -> c0152
            Verbose -> v
            ModuleName -> self
            ShellType -> /bin/sh
            MaxCallLayers -> 8
            MaxModuelCallLayers -> 256
          work dir: /up-project/up
          -exec task: task
          loading [Task]:  ./tests/functests/c0152
          module: [self] instance id: [dev]
          pipein: {
            "args": {},
            "headers": {
              "Accept": "application/json",
              "Host": "httpbin.org",
              "User-Agent": "curl/7.54.0",
              "X-Amzn-Trace-Id": "Root=1-5f0475af-708d0cca558974455b9e2fe8"
            },
            "origin": "14.202.210.195",
            "url": "http://httpbin.org/get"
          }

          Task1: [task ==> task: process the stdin pipe-in data ]
          -Step1:
          ~SubStep1: [inspect:  ]
            1: inspect[exec_vars](*core.Cache)({
              "up_runtime_task_pipe_in_content": "{\n  \"args\": {}, \n  \"headers\": {\n    \"Accept\": \"application/json\", \n    \"Host\": \"httpbin.org\", \n    \"User-Agent\": \"curl/7.54.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5f0475af-708d0cca558974455b9e2fe8\"\n  }, \n  \"origin\": \"14.202.210.195\", \n  \"url\": \"http://httpbin.org/get\"\n}\n"
          })

          ~SubStep2: [print: this is the pipe in string content ]
            {
              "args": {},
              "headers": {
                "Accept": "application/json",
                "Host": "httpbin.org",
                "User-Agent": "curl/7.54.0",
                "X-Amzn-Trace-Id": "Root=1-5f0475af-708d0cca558974455b9e2fe8"
              },
              "origin": "14.202.210.195",
              "url": "http://httpbin.org/get"
            }

          ~SubStep3: [toObj:  ]
          ~SubStep4: [printObj: this is the pipe in object ]
          object:
            my_http_get_response: {
              "args": {
              },
              "headers": {
                "Accept": "application/json",
                "Host": "httpbin.org",
                "User-Agent": "curl/7.54.0",
                "X-Amzn-Trace-Id": "Root=1-5f0475af-708d0cca558974455b9e2fe8"
              },
              "origin": "14.202.210.195",
              "url": "http://httpbin.org/get"
            }

          ~SubStep5: [print: access the object ]
          "headers": {
            User-Agent: curl/7.54.0,
            "X-Amzn-Trace-Id": "Root=1-5f0475af-708d0cca558974455b9e2fe8",
            "Accept": "application/json",
            "Host": "httpbin.org",
          }

        ```

    - title: how does it work
      content: |
        This case shows that the output of a restapi call to http://httpbin.org/get will be the a pipe in input to UPcmd, then the result is automatically saved to register name: up_runtime_task_pipe_in_content

        Initially the input result is always a string, then we use toObj cmd to auto convert it to a object named my_http_get_response, then we will be able to access the whole object

        Please note that the command will use the assigned task name for execution, however it is up to the user to design the workflow to decide how and what to use the register pipein value

    - title: extended use case
      content: |
        You could use UPcmd in following way:

        * register the input and parse it to an object, process it and pass it on for your task
        * chain it through to another UPcmd, eg.
        ```
          cmd1 | up ngo task1 | up ngo task2 | cmd2 | up ngo task3 | ......
        ```

        It is not recommend to chain directly to another UPcmd as you could route it internally.

notes:
  - add std pipe in feature
  - register the piped in content to a default register name
  - leave it to be up to the task to take care how to process the data

tasks:
  -
    name: task
    desc: process the stdin pipe-in data
    task:

      -
        func: cmd
        do:
          - name: inspect
            cmd:
              - exec_vars

          - name: print
            desc: this is the pipe in string content
            cmd: '{{.up_runtime_task_pipe_in_content}}'

          - name: toObj
            cmd:
              reg: my_http_get_response
              fromkey: up_runtime_task_pipe_in_content

          - name: printObj
            desc: this is the pipe in object
            cmd: my_http_get_response

          - name: print
            desc: access the object
            cmd: |
              "headers": {
                User-Agent: {{index .my_http_get_response.headers "User-Agent"}},
                "X-Amzn-Trace-Id": "{{index .my_http_get_response.headers "X-Amzn-Trace-Id"}}",
                "Accept": "{{.my_http_get_response.headers.Accept}}",
                "Host": "{{.my_http_get_response.headers.Host}}",
              }