Exemplo n.º 1
0
//Helper function to import the Master channel from masterAddr
func importMasterChan(t Task) (c chan WorkSummary, err os.Error) {
	mu.Lock()
	defer mu.Unlock()
	if c, present := _sessions[t.Session.Id]; present {
		log.Printf("Cached Session %v", t.Session.Id)
		return c, nil
	}

	imp, err := netchan.Import("tcp", t.MasterAddr)
	if err != nil {
		log.Printf("Failed to create importer for %v", t.MasterAddr)
		return nil, err
	}

	c = make(chan WorkSummary, 10)
	imp.Import("masterChannel", c, netchan.Send, 10)
	go func() {
		err := <-imp.Errors()
		log.Print(err)
	}()

	_sessions[t.Session.Id] = c
	go cacheWatcher(t.Session)
	return c, nil
}
Exemplo n.º 2
0
func main() {
	host := flag.String("host", "localhost:8001", "remote host")
	flag.Parse()
	fmt.Printf("attaching to %s\n", host)
	imp, err := netchan.Import("tcp", *host)
	if err != nil {
		log.Fatal(err)
	}
	ch := make(chan string)
	err = imp.ImportNValues("pingme", ch, netchan.Recv, 1, -1)
	if err != nil {
		log.Fatal(err)
	}
	errors := imp.Errors()
loop:
	for {
		select {
		case t, ok := <-ch:
			if !ok {
				fmt.Printf("channel closed\n")
				break loop
			}
			fmt.Printf("got %v\n", t)
		case e := <-errors:
			fmt.Printf("error %v\n", e)
			break loop
		}
	}
}
Exemplo n.º 3
0
//Creates a new Proxy importing 'workerChannel' from Worker running
//on workerAddr
func NewProxyWorker(workerAddr string) (p *ProxyWorker, err os.Error) {
	log.Printf("Setting up a ProxyWorker for %s", workerAddr)
	p = new(ProxyWorker)

	imp, err := netchan.Import("tcp", workerAddr)
	if err != nil {
		return
	}
	p.importer = imp
	return
}
Exemplo n.º 4
0
func client(name string, port string, done chan bool) {
	l := log.New(os.Stdout, fmt.Sprintf("client [%v]: ", name), 0)

	ch_recv := make(chan chan_type)
	imp, err := netchan.Import("tcp", port)

	if err != nil {
		l.Fatal(err)
	}

	err = imp.Import(name, ch_recv, netchan.Recv, 1)
	if err != nil {
		l.Fatal(err)
	}

	for v := range ch_recv {
		l.Println(v)
	}

	done <- true
}
Exemplo n.º 5
0
func main() {
	var r *bool
	var t *bool
	r = flag.Bool("rps", false, "Play a game of Rock-Paper-Scissors")
	t = flag.Bool("ttt", false, "Play a game of Tick-Tack-Toe")
	flag.Parse()

	args := flag.Args()
	var port string
	if len(args) == 1 {
		port = args[0]
	} else {
		fmt.Fprint(os.Stderr, "You must provide a port to connect to.")
		return
	}

	if *r && *t {
		fmt.Fprintln(os.Stderr, "You can only play one game at a time.")
		return
	} else if !(*r || *t) {
		// connext to an exporter with an importer
		// run the importer loop
		v2 := games.NewView()

		importer, err := netchan.Import("tcp", "localhost"+port)
		if err != nil {
			fmt.Fprintln(os.Stderr, err.String())
			return
		}

		err = importer.Import("Request", v2.Request, netchan.Recv, 1)
		if err != nil {
			fmt.Fprintln(os.Stderr, err.String())
			return
		}

		err = importer.Import("Responce", v2.Response, netchan.Send, 1)
		if err != nil {
			fmt.Fprintln(os.Stderr, err.String())
			return
		}

		ov2 := &games.ViewView{v2, os.Stdin, os.Stdout}

		ov2.Loop()

		return
	}

	var game games.Igame

	if *r {
		game = rps.NewGame()
	} else if *t {
		game = ttt.NewGame()
	}

	v1 := games.NewView()
	v2 := games.NewView() // <- this will be the exported/inported thingy
	ref := games.NewReferee(game, v1, v2)

	exporter := netchan.NewExporter()
	exporter.Export("Request", v2.Request, netchan.Send)
	exporter.Export("Responce", v2.Response, netchan.Recv)

	exporter.ListenAndServe("tcp", port)

	ov1 := &games.ViewView{v1, os.Stdin, os.Stdout}

	go ov1.Loop()

	ref.Loop()
	return
}
Exemplo n.º 6
0
func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: share [options] tcp-addr\n")
		flag.PrintDefaults()
		os.Exit(2)
	}
	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		return
	}
	addr := flag.Arg(0)
	if *server {
		exp := netchan.NewExporter()
		if err := exp.ListenAndServe("tcp", addr); err != nil {
			log.Fatal("listen failed: ", err)
		}
		listener, err := ncnet.Listen(exp, "ctl")
		if err != nil {
			log.Fatal("ncnet listen failed: ", err)
		}
		srv := &Server{
			exp:     exp,
			clients: make(map[string]*rpc.Client),
		}
		rpcsrv := rpc.NewServer()
		if err := rpcsrv.Register(srv); err != nil {
			log.Fatal("rpcsrv register failed: ", err)
		}
		rpcsrv.Accept(listener)
		listener.Close()
		return
	}

	imp, err := netchan.Import("tcp", addr)
	if err != nil {
		log.Fatal("netchan import failed: ", err)
	}
	srvconn, err := ncnet.Dial(imp, "ctl")
	if err != nil {
		log.Fatal("ncnet dial failed: ", err)
	}
	srv := rpc.NewClient(srvconn)

	var clientId string
	if err := srv.Call("Server.Publish", clientName, &clientId); err != nil {
		log.Fatal("publish failed: %v", err)
	}

	clientsrv := rpc.NewServer()
	if err := clientsrv.Register(Client{}); err != nil {
		log.Fatal("clientsrv register failed: ", err)
	}

	clientconn, err := ncnet.Dial(imp, clientId)
	if err != nil {
		log.Fatalf("ncnet dial %q failed: %v", clientId, err)
	}

	go clientsrv.ServeConn(clientconn)
	interact(srv)
	clientconn.Close()
	time.Sleep(0.1e9) // wait for close to propagate
}