Exécuter un autre programme de go à partir de l'intérieur d'un programme golang

Il y a beaucoup de façons de le faire Interopérabilité :

1 - je vous recommande d'utiliser le standard golang paquet (Lib), appelant, à la place de l'Interopérabilité, si vous avez des fichiers source des deux côtés.

2 - à l'aide de "os/exec": si vous n'avez pas de source, et vous avez seulement binaire,
ou vous pouvez passer des arguments par le biais de fichiers ou d'un texte args:

vous pouvez passer des arguments comme ceci:

package main

import (
    "fmt"
    "os"
)

func main() {

    fmt.Println(os.Args[0]) //fileNameAndPath
}

ou à l'aide de "drapeau" std lib:

//flags.exe -h
package main

import (
    "flag"
    "fmt"
)

func main() {
    namePtr := flag.String("name", "AR", "name")
    agePtr := flag.Int("age", 3700, "age")
    flag.Parse()
    fmt.Println(*namePtr, *agePtr) //AR 3700
}

/*
Usage of flags.exe:
  -age int
        age (default 3700)
  -name string
        name (default "AR")
*/

qui offre -h pour obtenir de l'aide.

et vous pouvez appeler un autre programme binaire ou golang compilateur lui-même comme ceci:

package main

import (
    "log"
    "os/exec"
)

func main() {
    cmnd := exec.Command("main.exe", "arg")
    //cmnd.Run() //and wait
    cmnd.Start()
    log.Println("log")
}

3 - une autre façon est d'appeler un programme externe en utilisant stdin /stdout.

de cette façon, vous pouvez envoyer des données binaires sur stdin/out:

Ici fichier "a" appels de fichier binaire "b" et l'envoie et reçoit par stdin/stdout:

c'est ma conversion à partir de :

http://erlang.org/doc/tutorial/c_port.html

(vous pouvez utiliser os tube nommé)

déposer une:

//a
package main
import (
"fmt"
"log"
"os/exec"
"runtime"
"time"
)
var cout chan []byte = make(chan []byte)
var cin chan []byte = make(chan []byte)
var exit chan bool = make(chan bool)
func Foo(x byte) byte { return call_port([]byte{1, x}) }
func Bar(y byte) byte { return call_port([]byte{2, y}) }
func Exit() byte      { return call_port([]byte{0, 0}) }
func call_port(s []byte) byte {
cout <- s
s = <-cin
return s[1]
}
func start() {
fmt.Println("start")
cmd := exec.Command("../b/b")
stdin, err := cmd.StdinPipe()
if err != nil {
log.Fatal(err)
}
stdout, err2 := cmd.StdoutPipe()
if err2 != nil {
log.Fatal(err2)
}
if err := cmd.Start(); err != nil {
log.Fatal(err)
}
defer stdin.Close()
defer stdout.Close()
for {
select {
case s := <-cout:
stdin.Write(s)
buf := make([]byte, 2)
runtime.Gosched()
time.Sleep(100 * time.Millisecond)
stdout.Read(buf)
cin <- buf
case b := <-exit:
if b {
fmt.Printf("Exit")
return //os.Exit(0)
}
}
}
}
func main() {
go start()
runtime.Gosched()
fmt.Println("30+1=", Foo(30)) //30+1= 31
fmt.Println("2*40=", Bar(40)) //2*40= 80
Exit()
exit <- true
}

fichier b:

//b
package main
import (
"log"
"os"
)
func foo(x byte) byte { return x + 1 }
func bar(y byte) byte { return y * 2 }
func ReadByte() byte {
b1 := make([]byte, 1)
for {
n, _ := os.Stdin.Read(b1)
if n == 1 {
return b1[0]
}
}
}
func WriteByte(b byte) {
b1 := []byte{b}
for {
n, _ := os.Stdout.Write(b1)
if n == 1 {
return
}
}
}
func main() {
var res byte
for {
fn := ReadByte()
log.Println("fn=", fn)
arg := ReadByte()
log.Println("arg=", arg)
if fn == 1 {
res = foo(arg)
} else if fn == 2 {
res = bar(arg)
} else if fn == 0 {
return //exit
} else {
res = fn //echo
}
WriteByte(1)
WriteByte(res)
}
}

4 - une autre façon est d'utiliser "net/rpc", c'est le meilleur moyen pour l'appel d'une autre fonction à partir d'un autre programme.

exemple:

//rpc
package main
import (
"fmt"
"net"
"net/rpc"
"runtime"
"sync"
)
var wg sync.WaitGroup
type Server struct{}
func (this *Server) Add(u [2]int64, reply *int64) error {
*reply = u[0] + u[1]
return nil
}
func server() {
fmt.Println("server: Hi")
rpc.Register(new(Server))
ln, err := net.Listen("tcp", "127.0.0.1:12345")
if err != nil {
fmt.Println(err)
return
}
for {
c, err := ln.Accept()
if err != nil {
continue
}
go rpc.ServeConn(c)
}
}
func client() {
wg.Add(1)
c, err := rpc.Dial("tcp", "127.0.0.1:12345")
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Connected...")
var result int64
err = c.Call("Server.Add", [2]int64{10, 20}, &result)
if err != nil {
fmt.Println(err)
} else {
fmt.Println("Server.Add(10,20) =", result)
}
wg.Done()
}
func main() {
go server()
runtime.Gosched()
go client()
runtime.Gosched()
wg.Wait()
fmt.Println("Bye")
}
/*output:
server: Hi
Connected...
Server.Add(10,20) = 30
Bye
*/

Créer un executabl fichier pour le forfait que vous souhaitez exécuter à partir d'un autre fichier. Fournir un chemin relatif pour le fichier que vous voulez exécuter à l'intérieur de exec.Command. Par exemple:

Fichier Un

package a
import "fmt"
func main(){
for i:=0;i<10;i++{
fmt.Println(fmt.Sprintf("Process: %d", i))
}
}

Créer un fichier binaire/exécutable pour le fichier ci-dessus. Le fichier sera à l'intérieur de l'emballage de manière à pied de l'emballage et de lancer le fichier exécutable.

go build github.com/user/a/a.go //or whatever be your GOPATH for executables to create a binary file

Ci-dessous est le cas du fichier binaire à l'intérieur de systèmes linux.

Fichier B

package b
import (
"fmt"
"os/exec"
)    
func main(){
//come out of package b and then go inside package a to run the executable file as
cmd := exec.Command("../a/a.go")
if err := cmd.Run(); err != nil{
fmt.Println(err)
}
}