package main

import (
    "errors"
    "fmt"
    "io"
    "io/ioutil"
    "os/exec"
)

type Dump struct {
    cmd *exec.Cmd
    stdIn io.WriteCloser
    stdErr io.ReadCloser
    stdOut io.ReadCloser
}

func (d *Dump) Wait() error {
    defer d.stdOut.Close()
    defer d.stdErr.Close()
    defer d.stdIn.Close()

    err := d.cmd.Wait()
    if exitError, ok := err.(*exec.ExitError); ok {
        status := exitError.ExitCode()
        if status != 0 {
            errout, _ := ioutil.ReadAll(d.stdErr)
            return errors.New(string(errout))
        }
    }
    return nil
}

func (d *Dump) Close() error {
    return nil
}

func Create() (*Dump, error) {

    cmd := exec.Command("/home/alex/Projects/jcluster/t.sh")

    stdIn, err := cmd.StdinPipe()
    if err != nil {
        return nil, err
    }

    stdErr, err := cmd.StderrPipe()
    if err != nil {
        return nil, err
    }

    stdOut, err := cmd.StdoutPipe()
    if err != nil {
        return nil, err
    }


    data := "asdasd\nsdfsdf\ndfgdfg"
    _, err = stdIn.Write([]byte(data))
    if err != nil {
        return nil, err
    }

    dump := &Dump{
        cmd:    cmd,
        stdIn:  stdIn,
        stdErr: stdErr,
        stdOut: stdOut,
    }

    err = dump.cmd.Start()
    if err != nil {
        return nil, err
    }

    return dump, nil
}

func Save(r io.Reader) error {
    p := make([]byte, 1024)
    for {
        l, err := r.Read(p)
        if err != nil {
            return err
        }
        data := string(p[:l])
        fmt.Println(data)
    }

    return nil
}

func main() {
    var dump *Dump

    go func() {
        d, err := Create()
        if err != nil {
            panic(err)
        }
        dump = d

        err = d.Wait()
        if err != nil {
            panic(err)
        }
    }()

    err := Save(dump.stdOut)
    if err != nil {
        panic(err)
    }
}