예제 #1
0
파일: example.go 프로젝트: simudream/duplex
func main() {
	if len(os.Args) < 2 {
		fmt.Println("Not enough args")
		os.Exit(2)
	}
	uri := os.Args[1]

	peer1 := duplex.NewPeer()
	peer1.SetOption(duplex.OptName, "peer1")
	err := peer1.Bind(uri)
	if err != nil {
		panic(err)
	}

	go func() {
		meta, ch := peer1.Accept()
		fmt.Println("accepted", meta.Service(), meta.Headers())
		for {
			frame, err := ch.ReadFrame()
			if err != nil {
				panic(err)
			}
			println("peer1 recv:", string(frame))
			err = ch.WriteFrame(frame)
			if err != nil {
				panic(err)
			}
		}
	}()

	peer2 := duplex.NewPeer()
	peer2.SetOption(duplex.OptName, "peer2")
	err = peer2.Connect(uri)
	if err != nil {
		panic(err)
	}

	println("connected")
	fmt.Println(peer1.Peers(), peer2.Peers())
	target := peer2.Peers()[0]
	ch, err := peer2.Open(target, "foobar", []string{"abc=123"})
	if err != nil {
		panic(err)
	}
	go func() {
		for {
			frame, err := ch.ReadFrame()
			if err != nil {
				panic(err)
			}
			println("peer2 recv:", string(frame))
		}
	}()

	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		ch.WriteFrame(scanner.Bytes())
	}
}
예제 #2
0
파일: rpc.go 프로젝트: simudream/duplex
func NewPeer() *Peer {
	return &Peer{
		Peer:        duplex.NewPeer(),
		contextType: reflect.TypeOf(""),
		serviceMap:  make(map[string]*service),
	}
}
예제 #3
0
func server(backendListen, frontendListen string) {
	// bind frontend
	frontend, err := net.Listen("tcp", frontendListen)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("frontend listening on", frontendListen, "...")
	mux, err := vhost.NewHTTPMuxer(frontend, 1*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	go func() {
		for {
			conn, err := mux.NextError()
			log.Println("vhost:", err)
			if conn != nil {
				conn.Write([]byte("error: " + err.Error()))
				conn.Close()
			}
		}
	}()

	// bind backend
	backend := duplex.NewPeer()
	err = backend.Bind("tcp://" + backendListen)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("backend listening on", backendListen, "...")
	for {
		meta, ch := backend.Accept()
		if meta == nil {
			break
		}
		// register vhost
		if meta.Service() == "tunnel" {
			log.Println("registering", meta.RemotePeer())
			vhostListener, err := mux.Listen(meta.RemotePeer())
			if err != nil {
				log.Println(err)
			}
			go func() {
				for {
					conn, err := vhostListener.Accept()
					if err != nil {
						log.Println(err)
					}
					tunnelCh, err := ch.Open("", nil)
					if err != nil {
						log.Println(err)
					}
					go tunnelCh.Join(conn)
				}
			}()
			continue
		}
	}
}
예제 #4
0
파일: gateway.go 프로젝트: u2mejc/plugn
func ReloadGateway(args []string) {
	gatewaySock := PluginPath + "/gateway.sock"
	if _, err := os.Stat(gatewaySock); os.IsNotExist(err) {
		return
	}
	trigger := duplex.NewPeer()
	defer trigger.Shutdown()
	trigger.SetOption(duplex.OptName, "plugn:reload")
	err := trigger.Connect("unix://" + gatewaySock)
	if err != nil {
		panic(err)
	}
	_, err = trigger.Open("plugn:gateway", "reload", nil)
	if err != nil {
		panic(err)
	}
}
예제 #5
0
파일: gateway.go 프로젝트: u2mejc/plugn
func TriggerGateway(args []string) {
	gatewaySock := PluginPath + "/gateway.sock"
	if _, err := os.Stat(gatewaySock); os.IsNotExist(err) {
		return
	}
	trigger := duplex.NewPeer()
	defer trigger.Shutdown()
	trigger.SetOption(duplex.OptName, "plugn:trigger")
	err := trigger.Connect("unix://" + gatewaySock)
	if err != nil {
		panic(err)
	}
	ch, err := trigger.Open("plugn:gateway", args[0], args[1:])
	if err != nil {
		panic(err)
	}
	io.Copy(os.Stdout, ch)
	ch.Close()
}
예제 #6
0
파일: remote.go 프로젝트: u2mejc/plugn
func main() {
	plugin := duplex.NewPeer()
	defer plugin.Shutdown()
	plugin.SetOption(duplex.OptName, "remote")
	err := plugin.Connect("unix://" + os.Getenv("PLUGIN_PATH") + "/gateway.sock")
	if err != nil {
		panic(err)
	}
	log.Println("remote: starting...")
	for {
		meta, ch := plugin.Accept()
		log.Println("remote: triggered:", meta.Service(), meta.Headers())
		switch meta.Service() {
		case "items":
			io.WriteString(ch, "Fake Remote, Item 1:5.00\n")
			io.WriteString(ch, "Fake Remote, Item 2:5.00\n")
		}
		ch.Close()
	}
}
예제 #7
0
파일: gateway.go 프로젝트: u2mejc/plugn
func startGateway(wg *sync.WaitGroup, plugins *coproc.Host) *duplex.Peer {
	gateway := duplex.NewPeer()
	gateway.SetOption(duplex.OptName, "plugn:gateway")
	err := gateway.Bind("unix://" + PluginPath + "/gateway.sock")
	if err != nil {
		panic(err)
	}
	wg.Add(1)
	go func() {
		for {
			meta, ch := gateway.Accept()
			if meta == nil {
				break
			}
			if meta.Service() == "reload" {
				log.Println("reload received...")
				plugins.RestartWith(findPlugins())
				ch.Close()
				continue
			}
			go func() {
				for _, peer := range gateway.Peers() {
					if !strings.HasPrefix(peer, "plugn") {
						hook, err := gateway.Open(peer, meta.Service(), meta.Headers())
						if err != nil {
							log.Println("unable to trigger", peer)
							continue
						}
						io.Copy(ch, hook)
						hook.Close()
					}
				}
				ch.Close()
			}()
		}
		wg.Done()
	}()
	return gateway
}