func TestBreaker(t *testing.T) {
// setup
r := mock.NewRegistry()
s := selector.NewSelector(selector.Registry(r))
c := client.NewClient(
// set the selector
client.Selector(s),
// add the breaker wrapper
client.Wrap(NewClientWrapper()),
)
req := c.NewJsonRequest("test.service", "Test.Method", map[string]string{
"foo": "bar",
})
var rsp map[string]interface{}
// Force to point of trip
for i := 0; i < (hystrix.DefaultVolumeThreshold * 2); i++ {
c.Call(context.TODO(), req, rsp)
}
err := c.Call(context.TODO(), req, rsp)
if err == nil {
t.Error("Expecting tripped breaker, got nil error")
}
if err.Error() != "hystrix: circuit open" {
t.Errorf("Expecting tripped breaker, got %v", err)
}
}
func main() {
cmd.Init()
t := zipkin.NewTrace(
trace.Collectors("192.168.99.100:9092"),
)
defer t.Close()
client.DefaultClient = client.NewClient(
client.Wrap(
trace.ClientWrapper(t, nil),
),
)
fmt.Println("\n--- Traced Call example ---\n")
for i := 0; i < 10; i++ {
call(i)
}
/*
fmt.Println("\n--- Streamer example ---\n")
stream(10)
fmt.Println("\n--- Ping Pong example ---\n")
pingPong(10)
fmt.Println("\n--- Publisher example ---\n")
pub()
*/
<-time.After(time.Second * 10)
}
func main() {
cmd.Init()
t := trace.NewTrace()
srv := ®istry.Service{
Name: "go.client",
}
client.DefaultClient = client.NewClient(
client.Wrap(
trace.ClientWrapper(t, srv),
),
)
fmt.Println("Starting trace")
if err := t.Start(); err != nil {
fmt.Println(err)
return
}
fmt.Println("\n--- Traced Call example ---\n")
i := 0
for {
call(i)
i++
<-time.After(time.Second * 5)
}
if err := t.Stop(); err != nil {
fmt.Println(err)
}
}
func main() {
cmd.Init()
fmt.Println("\n--- Log Wrapper example ---\n")
// Wrap the default client
client.DefaultClient = logWrap(client.DefaultClient)
call(0)
fmt.Println("\n--- Log+Trace Wrapper example ---\n")
// Wrap using client.Wrap option
client.DefaultClient = client.NewClient(
client.Wrap(traceWrap),
client.Wrap(logWrap),
)
call(1)
}
func main() {
cmd.Init()
client.DefaultClient = client.NewClient(
client.Wrap(NewDCWrapper),
)
fmt.Println("\n--- Call example ---\n")
for i := 0; i < 10; i++ {
call(i)
}
}
func main() {
// Create a new service. Optionally include some options here.
service := micro.NewService(
micro.Client(client.NewClient(client.Wrap(logWrap))),
micro.Server(server.NewServer(server.WrapHandler(logHandlerWrapper))),
micro.Name("greeter"),
micro.Version("latest"),
micro.Metadata(map[string]string{
"type": "helloworld",
}),
// Setup some flags. Specify --client to run the client
// Add runtime flags
// We could do this below too
micro.Flags(cli.BoolFlag{
Name: "client",
Usage: "Launch the client",
}),
)
// Init will parse the command line flags. Any flags set will
// override the above settings. Options defined here will
// override anything set on the command line.
service.Init(
// Add runtime action
// We could actually do this above
micro.Action(func(c *cli.Context) {
if c.Bool("client") {
runClient(service)
os.Exit(0)
}
}),
)
// By default we'll run the server unless the flags catch us
// Setup the server
// Register handler
proto.RegisterGreeterHandler(service.Server(), new(Greeter))
// Run the server
if err := service.Run(); err != nil {
fmt.Println(err)
}
}
func main() {
// optionally setup command line usage
cmd.Init()
t := trace.NewTrace()
defer t.Close()
srv := ®istry.Service{
Name: "go.micro.srv.example",
}
client.DefaultClient = client.NewClient(
client.Wrap(
trace.ClientWrapper(t, srv),
),
)
server.DefaultServer = server.NewServer(
server.WrapHandler(trace.HandlerWrapper(t, srv)),
)
// Initialise Server
server.Init(
server.Name("go.micro.srv.example"),
)
// Register Handlers
server.Handle(
server.NewHandler(
new(handler.Example),
),
)
server.Handle(
server.NewHandler(
new(Ping),
),
)
// Run server
if err := server.Run(); err != nil {
log.Fatal(err)
}
}
func main() {
cmd.Init()
t := zipkin.NewTrace(
trace.Collectors([]string{"192.168.99.100:9092"}),
)
client.DefaultClient = client.NewClient(
client.Wrap(
trace.ClientWrapper(t, nil),
),
)
fmt.Println("Starting trace")
if err := t.Start(); err != nil {
fmt.Println(err)
return
}
fmt.Println("\n--- Traced Call example ---\n")
for i := 0; i < 10; i++ {
call(i)
}
/*
fmt.Println("\n--- Streamer example ---\n")
stream(10)
fmt.Println("\n--- Ping Pong example ---\n")
pingPong(10)
fmt.Println("\n--- Publisher example ---\n")
pub()
*/
<-time.After(time.Second * 10)
if err := t.Stop(); err != nil {
fmt.Println(err)
}
}
func main() {
cmd.Init()
t := trace.NewTrace()
defer t.Close()
srv := ®istry.Service{
Name: "go.micro.client.example",
}
client.DefaultClient = client.NewClient(
client.Wrap(
trace.ClientWrapper(t, srv),
),
)
fmt.Println("\n--- Traced Call example ---\n")
i := 0
for {
call(i)
i++
<-time.After(time.Second * 5)
}
}