| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // +build ignore |
| |
| // pg-index=1 |
| package main |
| |
| import ( |
| "fmt" |
| "math/rand" |
| |
| "v.io/v23" |
| "v.io/v23/context" |
| "v.io/v23/rpc" |
| "v.io/x/lib/vlog" |
| "v.io/x/ref/lib/security/securityflag" |
| "v.io/x/ref/lib/signals" |
| _ "v.io/x/ref/runtime/factories/roaming" |
| |
| "fortune" |
| ) |
| |
| // The Fortuned implementation. |
| type fortuned struct { |
| // The set of all fortunes. |
| fortunes []string |
| |
| // Used to pick a random index in 'fortunes'. |
| random *rand.Rand |
| } |
| |
| // Initialize server state. |
| func newFortuned() *fortuned { |
| return &fortuned{ |
| fortunes: []string{ |
| "You will reach the height of success in whatever you do.", |
| "You have remarkable power which you are not using.", |
| "Everything will now come your way.", |
| }, |
| random: rand.New(rand.NewSource(99)), |
| } |
| } |
| |
| // Methods that get called by RPC requests. |
| func (f *fortuned) GetRandomFortune(*context.T, rpc.ServerCall) (Fortune string, err error) { |
| Fortune = f.fortunes[f.random.Intn(len(f.fortunes))] |
| fmt.Printf("Serving: %s\n", Fortune) |
| return Fortune, nil |
| } |
| |
| func (f *fortuned) AddNewFortune(_ *context.T, _ rpc.ServerCall, Fortune string) error { |
| fmt.Printf("Adding: %s\n", Fortune) |
| f.fortunes = append(f.fortunes, Fortune) |
| return nil |
| } |
| |
| // Main - Set everything up. |
| func main() { |
| // Initialize Vanadium. |
| ctx, shutdown := v23.Init() |
| defer shutdown() |
| |
| // TODO(ivanpi): The playground executor should somehow force the |
| // ListenSpec to be this way. |
| // When a ListenSpec is not explicitly specified, the "roaming" runtime |
| // factory sets it up to be the public IP address of the virtual |
| // machine running on Google Compute Engine or Amazon Web Services. |
| // Normally, the playground should execute code inside a docker image, |
| // but in tests it is run on the host machine and having this test |
| // service exported on a public IP (when running on GCE) is not an |
| // intent. Furthermore, the test may fail if the firewall rules block |
| // access to the selected port on the public IP. |
| ctx = v23.WithListenSpec(ctx, rpc.ListenSpec{ |
| Addrs: rpc.ListenAddrs{{"tcp", "127.0.0.1:0"}}, |
| }) |
| |
| // Create the fortune server stub. |
| fortuneServer := fortune.FortuneServer(newFortuned()) |
| |
| // Create a new instance of the runtime's server functionality. |
| ctx, server, err := v23.WithNewServer(ctx, "bakery/cookie/fortune", fortuneServer, securityflag.NewAuthorizerOrDie()) |
| if err != nil { |
| vlog.Panic("failure creating server: ", err) |
| } |
| fmt.Printf("Listening at: %v\n", server.Status().Endpoints[0]) |
| fmt.Printf("Fortune server serving under: bakery/cookie/fortune\n") |
| |
| // Wait forever. |
| <-signals.ShutdownOnSignals(ctx) |
| } |
