Can I use a single powershell.exe to execute multi-lines command?

[hanqiang2]

Is there any way allow me to execute powershell commands like below? If I can execute commands in one context, then I think I can control the shell more flexible.
Currently, I check the len(stdout) to confirm if the outputs is completely wrote to buffer. But when several commands executed, the new output will be empty.

	shell, err := client.CreateShell()
	if err != nil {
		panic(err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	var cmd *winrm.Command
	cmd, err = shell.ExecuteWithContext(ctx, "powershell.exe")
	if err != nil {
		panic(err)
	}

	var bufOut bytes.Buffer
	var bufErr bytes.Buffer

	go io.Copy(&bufOut, cmd.Stdout)
	go io.Copy(&bufErr, cmd.Stderr)

	stdout, _ := ExecuteCommand(cmd, &bufOut, &bufErr, "hostname")
	fmt.Printf(stdout)

	stdout, _ = ExecuteCommand(cmd, &bufOut, &bufErr, "Get-ClusterNode | ConvertTo-Json -Compress")
	fmt.Printf(stdout)

	stdout, _ = ExecuteCommand(cmd, &bufOut, &bufErr, "Get-Cluster | ConvertTo-Json -Compress")
	fmt.Printf(stdout)

	cmd.Stdin.Close()

	cmd.Wait()
	cmd.Close()
	shell.Close()
	return

func ExecuteCommand(cmd *winrm.Command, bufOut *bytes.Buffer, bufErr *bytes.Buffer, script string) (string, string) {
	stdin := bytes.NewBufferString(script + `
`)
	io.Copy(cmd.Stdin, stdin)

       time.sleep(xxx) // I don't know when and where I can handle a command done signal.

	var newBufOut bytes.Buffer
	var newBufErr bytes.Buffer
	io.Copy(&newBufOut, bufOut)
	io.Copy(&newBufErr, bufErr)
}
	return newBufOut.String(), newBufErr.String()

[hanqiang2]

Simply I worked it out the way below.

func main() {
	endpoint := winrm.NewEndpoint("", 5985, false, false, nil, nil, nil, 0)
	params := winrm.DefaultParameters
	params.TransportDecorator = func() winrm.Transporter { return &winrm.ClientNTLM{} }

	client, err := winrm.NewClientWithParameters(endpoint, "", "", params)
	if err != nil {
		panic(err)
	}

	shell, err := client.CreateShell()

	if err != nil {
		panic(err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	var cmd *winrm.Command
	cmd, err = shell.ExecuteWithContext(ctx, "powershell.exe")
	if err != nil {
		panic(err)
	}

	var bufOut bytes.Buffer
	var bufErr bytes.Buffer

	go io.Copy(&bufOut, cmd.Stdout)
	go io.Copy(&bufErr, cmd.Stderr)

	stdout, _ := ExecuteCommand(cmd, &bufOut, &bufErr, ``)

	stdout, _ = ExecuteCommand(cmd, &bufOut, &bufErr, "hostname")
	fmt.Printf(stdout)
	fmt.Printf(`
----------------------------------
`)

	stdout, _ = ExecuteCommand(cmd, &bufOut, &bufErr, "Get-ClusterNode | ConvertTo-Json -Compress")
	fmt.Printf(stdout)
	fmt.Printf(`
----------------------------------
`)

	stdout, _ = ExecuteCommand(cmd, &bufOut, &bufErr, "Get-ComputerInfo | ConvertTo-Json -Compress")
	fmt.Printf(stdout)
	fmt.Printf(`
----------------------------------
`)
	cmd.Stdin.Close()

	cmd.Wait()
	shell.Close()
	return
}

var seek = 0

func ExecuteCommand(cmd *winrm.Command, bufOut *bytes.Buffer, bufErr *bytes.Buffer, script string) (string, string) {
	stdin := bytes.NewBufferString(script + `
`)
	if script == "" {
		stdin = bytes.NewBufferString(script)
	}

	seek = seek + stdin.Len()
	go io.Copy(cmd.Stdin, stdin)

	timeout := 100 * time.Second
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()

	var lines []string
	lines = append(lines, "")
	for {
		if ctx.Err() != nil {
			fmt.Println("Timeout reached:", ctx.Err())
			return "", "timeout"
		}

		var newBufOut bytes.Buffer
		var discard bytes.Buffer
		io.CopyN(&discard, bufOut, int64(seek))
		io.Copy(&newBufOut, bufOut)
		seek += newBufOut.Len()
		outstring := newBufOut.String()

		for i, v := range strings.Split(outstring, "\r\n") {
			if i != 0 {
				lines = append(lines, "")
			}
			lines[len(lines)-1] += v
		}

		matched, _ := regexp.MatchString("^PS .+> $", lines[len(lines)-1])
		if matched {
			break
		}
		time.Sleep(10 * time.Millisecond)
	}
	var newBufErr bytes.Buffer
	io.Copy(&newBufErr, bufErr)

	if len(lines) >= 2 {
		return lines[len(lines)-2], newBufErr.String()
	}

	return "", newBufErr.String()
}