Как выполнить системную команду в Голанге с неизвестными аргументами

У меня есть набор системных команд, которые немного похожи на добавление нового содержимого в файл. Я написал простой script для выполнения системных команд, который хорошо работает, если есть такие слова, как "ls", "date" и т.д. Но если команда больше, программа умирает.

Ниже приведен код

package main

import (
    "fmt"
    "os/exec"
    "sync"
)

func exe_cmd(cmd string, wg *sync.WaitGroup) {
    fmt.Println(cmd)
    c = cmd.Str
    out, err := exec.Command(cmd).Output()
    if err != nil {
        fmt.Println("error occured")
        fmt.Printf("%s", err)
    }
    fmt.Printf("%s", out)
    wg.Done()
}

func main() {
    wg := new(sync.WaitGroup)
    wg.Add(3)

    x := []string{"echo newline >> foo.o", "echo newline >> f1.o", "echo newline >> f2.o"}
    go exe_cmd(x[0], wg)
    go exe_cmd(x[1], wg)
    go exe_cmd(x[2], wg)

    wg.Wait()
}

Ниже приведена ошибка, которую я вижу

exec: "echo newline >> foo.o": executable file not found in $PATHexec: 
"echo newline >> f2.o": executable file not found in $PATHexec: 
"echo newline >> f1.o": executable file not found in $PATH

Я думаю, это может быть связано с тем, что не отправляйте cmds и аргументы отдельно (http://golang.org/pkg/os/exec/#Command). Мне интересно, как подорвать это, так как я не знаю, сколько аргументов будет в моей команде, которая должна быть выполнена.

Ответы

Ответ 1

Я нашел относительно приличный способ добиться того же.

out, err := exec.Command("sh","-c",cmd).Output()

Работает для меня до сих пор. Тем не менее найти лучшие способы достичь того же.

Edit1:

Наконец, более простой и эффективный способ (по крайней мере, до сих пор) был бы таким:

func exe_cmd(cmd string, wg *sync.WaitGroup) {
  fmt.Println("command is ",cmd)
  // splitting head => g++ parts => rest of the command
  parts := strings.Fields(cmd)
  head := parts[0]
  parts = parts[1:len(parts)]

  out, err := exec.Command(head,parts...).Output()
  if err != nil {
    fmt.Printf("%s", err)
  }
  fmt.Printf("%s", out)
  wg.Done() // Need to signal to waitgroup that this goroutine is done
}

Благодаря вариационным аргументам в go и людям, которые указали на это мне:)

Ответ 2

Для exec.Command() первым аргументом должен быть путь к исполняемому файлу. Затем остальные аргументы будут предоставлены в качестве аргументов исполняемому файлу. Используйте strings.Fields(), чтобы помочь разбить слово на строку [].

Пример:

package main

import (
    "fmt"
    "os/exec"
    "sync"
    "strings"
)

func exe_cmd(cmd string, wg *sync.WaitGroup) {
    fmt.Println(cmd)
            parts := strings.Fields(cmd)
    out, err := exec.Command(parts[0],parts[1]).Output()
    if err != nil {
        fmt.Println("error occured")
        fmt.Printf("%s", err)
    }
    fmt.Printf("%s", out)
    wg.Done()
}

func main() {
    wg := new(sync.WaitGroup)
    commands := []string{"echo newline >> foo.o", "echo newline >> f1.o", "echo newline >> f2.o"}
    for _, str := range commands {
        wg.Add(1)
        go exe_cmd(str, wg)
    }
    wg.Wait()
}

Здесь альтернативный подход, который просто записывает все команды в файл, затем выполняет этот файл в контексте нового созданного выходного каталога.

Пример 2

package main

import (
    "os"
    "os/exec"
    "fmt"
    "strings"
    "path/filepath"
)
var (
    output_path = filepath.Join("./output")
    bash_script = filepath.Join( "_script.sh" )
)
func checkError( e error){
    if e != nil {
        panic(e)
    }
}
func exe_cmd(cmds []string) {
    os.RemoveAll(output_path)
    err := os.MkdirAll( output_path, os.ModePerm|os.ModeDir )
    checkError(err)
    file, err := os.Create( filepath.Join(output_path, bash_script))
    checkError(err)
    defer file.Close()
    file.WriteString("#!/bin/sh\n")
    file.WriteString( strings.Join(cmds, "\n"))
    err = os.Chdir(output_path)
    checkError(err)
    out, err := exec.Command("sh", bash_script).Output()
    checkError(err)
    fmt.Println(string(out))
}

func main() {
    commands := []string{
    "echo newline >> foo.o",
    "echo newline >> f1.o",
    "echo newline >> f2.o",
    }
   exe_cmd(commands)
}

Ответ 3

echo не является системной. Это оболочка, встроенная и, следовательно, не имеющая прямого доступа из exec

Ответ 4

    out, _ := exec.Command("sh", "-c", "date +\"%Y-%m-%d %H:%M:%S %Z\"").Output()
    exec.Command("sh","-c","ls -al -t | grep go >>test.txt").Output()
    fmt.Printf("%s\n\n",out)

Протестированные пары случаев и все работают хорошо. Это спасатель, если вы имеете дело с быстрыми командами оболочки в своей программе. Не тестируется в сложных случаях.