func Dial(addr string) (*GearConn, error) {
log.Printf("Opening libchan connection to %s", addr)
conn, err := net.Dial("tcp", addr)
if err != nil {
return nil, err
}
transport, err := spdy.NewClientTransport(conn)
if err != nil {
conn.Close()
return nil, err
}
main, err := transport.NewSendChannel()
if err != nil {
conn.Close()
return nil, err
}
if err := doEcho(main, time.Second); err != nil {
conn.Close()
return nil, fmt.Errorf("initial echo %s", err.Error())
}
log.Printf("Libchan connection to %s open", addr)
gc := &GearConn{conn: conn, mainChan: main, addr: addr}
go gc.pinger()
return gc, nil
}
func main() {
if len(os.Args) < 2 {
log.Fatal("usage: <command> [<arg> ]")
}
var client net.Conn
var err error
if os.Getenv("USE_TLS") != "" {
client, err = tls.Dial("tcp", "127.0.0.1:9323", &tls.Config{InsecureSkipVerify: true})
} else {
client, err = net.Dial("tcp", "127.0.0.1:9323")
}
if err != nil {
log.Fatal(err)
}
transport, err := spdy.NewClientTransport(client)
if err != nil {
log.Fatal(err)
}
sender, err := transport.NewSendChannel()
if err != nil {
log.Fatal(err)
}
receiver, remoteSender := libchan.Pipe()
command := &RemoteCommand{
Cmd: os.Args[1],
Args: os.Args[2:],
Stdin: os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
StatusChan: remoteSender,
}
err = sender.Send(command)
if err != nil {
log.Fatal(err)
}
response := &CommandResponse{}
err = receiver.Receive(response)
if err != nil {
log.Fatal(err)
}
os.Exit(response.Status)
}
func NewRemoteRepository(remoteURL string) ThingeyRepository {
receiver, remoteSender := libchan.Pipe()
var client net.Conn
var err error
client, err = net.Dial("tcp", remoteURL)
if err != nil {
log.Fatal(err)
}
transport, err := spdy.NewClientTransport(client)
if err != nil {
log.Fatal(err)
}
return NewThingeyRepository(transport.NewSendChannel, receiver, remoteSender)
}
func Client(task *Task, proto *string, socket *string) int {
var client net.Conn
var err error
if os.Getenv("USE_TLS") != "" {
client, err = tls.Dial(*proto, *socket, &tls.Config{InsecureSkipVerify: true})
} else {
client, err = net.Dial(*proto, *socket)
}
if err != nil {
log.Fatal(err)
}
transport, err := spdy.NewClientTransport(client)
if err != nil {
log.Fatal(err)
}
sender, err := transport.NewSendChannel()
if err != nil {
log.Fatal(err)
}
receiver, remoteSender := libchan.Pipe()
//_, remoteSender := libchan.Pipe()
command := &Command{
Cmd: task.Module,
Args: task.Args[0:],
Stdin: os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
StatusChan: remoteSender,
}
err = sender.Send(command)
if err != nil {
log.Fatal(err)
}
//sender.Close()
response := &CommandResponse{}
err = receiver.Receive(response)
if err != nil {
log.Fatal(err)
}
//command.StatusChan.Close()
//sender.Close()
//remoteSender.Close()
//client.Close()
return response.Status
// os.Exit(response.Status)
}
// Start starts the designated child process storage driver and binds a socket
// to this process for IPC method calls
func (driver *StorageDriverClient) Start() error {
driver.exitErr = nil
driver.exitChan = make(chan error)
driver.stopChan = make(chan struct{})
fileDescriptors, err := syscall.Socketpair(syscall.AF_LOCAL, syscall.SOCK_STREAM, 0)
if err != nil {
return err
}
childSocket := os.NewFile(uintptr(fileDescriptors[0]), "childSocket")
driver.socket = os.NewFile(uintptr(fileDescriptors[1]), "parentSocket")
driver.subprocess.Stdout = os.Stdout
driver.subprocess.Stderr = os.Stderr
driver.subprocess.ExtraFiles = []*os.File{childSocket}
if err = driver.subprocess.Start(); err != nil {
driver.Stop()
return err
}
go driver.handleSubprocessExit()
if err = childSocket.Close(); err != nil {
driver.Stop()
return err
}
connection, err := net.FileConn(driver.socket)
if err != nil {
driver.Stop()
return err
}
driver.transport, err = spdy.NewClientTransport(connection)
if err != nil {
driver.Stop()
return err
}
driver.sender, err = driver.transport.NewSendChannel()
if err != nil {
driver.Stop()
return err
}
// Check the driver's version to determine compatibility
receiver, remoteSender := libchan.Pipe()
err = driver.sender.Send(&Request{Type: "Version", ResponseChannel: remoteSender})
if err != nil {
driver.Stop()
return err
}
var response VersionResponse
err = receiver.Receive(&response)
if err != nil {
driver.Stop()
return err
}
if response.Error != nil {
return response.Error.Unwrap()
}
driver.version = response.Version
if driver.version.Major() != storagedriver.CurrentVersion.Major() || driver.version.Minor() > storagedriver.CurrentVersion.Minor() {
return IncompatibleVersionError{driver.version}
}
return nil
}
var dbDir string
BeforeEach(func() {
dbDir = fmt.Sprintf("/tmp/db-%d", os.Getpid())
db, _ = database.Open(dbDir) // db is global defined in main.go
var err error
serverListener, err = net.Listen("tcp", "localhost:9323")
Ω(err).ShouldNot(HaveOccurred())
go ServeChan(serverListener)
time.Sleep(10 * time.Millisecond)
clientConn, err = net.Dial("tcp", "127.0.0.1:9323")
Ω(err).ShouldNot(HaveOccurred())
transport, err := spdy.NewClientTransport(clientConn)
Ω(err).ShouldNot(HaveOccurred())
clientSender, err = transport.NewSendChannel()
Ω(err).ShouldNot(HaveOccurred())
})
AfterEach(func() {
if clientConn != nil {
clientConn.Close()
}
if serverListener != nil {
fmt.Printf("Closing serverListener\n")
serverListener.Close()
}
time.Sleep(10 * time.Millisecond)
