func main() { // Create a TChannel and listen for inbound connections. ch, err := tchannel.NewChannel("keyvalue", nil) if err != nil { log.Fatalf("Failed to create tchannel: %v", err) } ip, err := tchannel.ListenIP() if err != nil { log.Fatalf("Failed to find IP to Listen on: %v", err) } ch.ListenAndServe(ip.String() + ":12345") // Register both the KeyValue and Admin services. h := newKVHandler() server := thrift.NewServer(ch) server.Register(keyvalue.NewTChanKeyValueServer(h)) server.Register(keyvalue.NewTChanAdminServer(h)) config := hyperbahn.Configuration{InitialNodes: os.Args[1:]} if len(config.InitialNodes) == 0 { log.Fatalf("No Autobahn nodes to advertise with") } client := hyperbahn.NewClient(ch, config, nil) if err := client.Advertise(); err != nil { log.Fatalf("Hyperbahn advertise failed: %v", err) } // The service is now started up, run it till we receive a ctrl-c. log.Printf("KeyValue service has started on %v", ch.PeerInfo().HostPort) select {} }
func main() { // Create a TChannel. ch, err := tchannel.NewChannel("keyvalue-client", nil) if err != nil { log.Fatalf("Failed to create tchannel: %v", err) } // Set up Hyperbahn client. config := hyperbahn.Configuration{InitialNodes: os.Args[1:]} if len(config.InitialNodes) == 0 { log.Fatalf("No Autobahn nodes to connect to given") } hyperbahn.NewClient(ch, config, nil) thriftClient := thrift.NewClient(ch, "keyvalue", nil) client := keyvalue.NewTChanKeyValueClient(thriftClient) adminClient := keyvalue.NewTChanAdminClient(thriftClient) // Read commands from the command line and execute them. scanner := bufio.NewScanner(os.Stdin) printHelp() fmt.Printf("> ") for scanner.Scan() { parts := strings.Split(scanner.Text(), " ") if parts[0] == "" { continue } switch parts[0] { case "help": printHelp() case "get": if len(parts) < 2 { printHelp() break } get(client, parts[1]) case "set": if len(parts) < 3 { printHelp() break } set(client, parts[1], parts[2]) case "user": if len(parts) < 2 { printHelp() break } curUser = parts[1] case "clearAll": clear(adminClient) default: log.Printf("Unsupported command %q\n", parts[0]) } fmt.Print("> ") } scanner.Text() }
// setupServer is the application code we are attempting to test. func setupServer() error { ch, err := tchannel.NewChannel("myservice", nil) if err != nil { return err } if err := ch.ListenAndServe("127.0.0.1:0"); err != nil { return err } client, err := hyperbahn.NewClient(ch, config.hyperbahnConfig, nil) if err != nil { return err } return client.Advertise() }
func main() { tchan, err := tchannel.NewChannel("go-echo-server", nil) if err != nil { log.Fatalf("Failed to create channel: %v", err) } listenIP, err := tchannel.ListenIP() if err != nil { log.Fatalf("Failed to get IP to listen on: %v", err) } l, err := net.Listen("tcp", listenIP.String()+":61543") if err != nil { log.Fatalf("Could not listen: %v", err) } log.Printf("Listening on %v", l.Addr()) sc := tchan.GetSubChannel("go-echo-2") tchan.Register(raw.Wrap(handler{""}), "echo") sc.Register(raw.Wrap(handler{"subchannel:"}), "echo") tchan.Serve(l) if len(os.Args[1:]) == 0 { log.Fatalf("You must provide Hyperbahn nodes as arguments") } // advertise service with Hyperbahn. config := hyperbahn.Configuration{InitialNodes: os.Args[1:]} client, err := hyperbahn.NewClient(tchan, config, &hyperbahn.ClientOptions{ Handler: eventHandler{}, Timeout: time.Second, }) if err != nil { log.Fatalf("hyperbahn.NewClient failed: %v", err) } if err := client.Advertise(sc); err != nil { log.Fatalf("Advertise failed: %v", err) } // Server will keep running till Ctrl-C. select {} }
func main() { // Create a TChannel and register the Thrift handlers. ch, err := tchannel.NewChannel("keyvalue", nil) if err != nil { log.Fatalf("Failed to create tchannel: %v", err) } // Register both the KeyValue and Admin services. // We can register multiple Thrift services on a single Hyperbahn service. h := newKVHandler() server := thrift.NewServer(ch) server.Register(keyvalue.NewTChanKeyValueServer(h)) server.Register(keyvalue.NewTChanAdminServer(h)) // Listen for connections on the external interface so we can receive connections. ip, err := tchannel.ListenIP() if err != nil { log.Fatalf("Failed to find IP to Listen on: %v", err) } // We use port 0 which asks the OS to assign any available port. // Static port allocations are not necessary for services on Hyperbahn. ch.ListenAndServe(fmt.Sprintf("%v:%v", ip, 0)) // Advertising registers this service instance with Hyperbahn so // that Hyperbahn can route requests for "keyvalue" to us. config := hyperbahn.Configuration{InitialNodes: os.Args[1:]} if len(config.InitialNodes) == 0 { log.Fatalf("No Autobahn nodes to advertise with") } client, err := hyperbahn.NewClient(ch, config, nil) if err != nil { log.Fatalf("hyperbahn.NewClient failed: %v", err) } if err := client.Advertise(); err != nil { log.Fatalf("Hyperbahn advertise failed: %v", err) } // The service is now started up, run it till we receive a ctrl-c. log.Printf("KeyValue service has started on %v", ch.PeerInfo().HostPort) select {} }