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 {}
}
