Remove verb-specific handler methods from Server

Signed-off-by: Aanand Prasad <aanand.prasad@gmail.com>

backends/aggregate.go

@@ -11,7 +11,7 @@ import (
 
 func Aggregate() beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		allBackends := New()
 		instance := beam.NewServer()
 
@@ -20,9 +20,9 @@ func Aggregate() beam.Sender {
 			return err
 		}
 
-		instance.OnAttach(beam.Handler(a.attach))
+		instance.OnVerb(beam.Attach, beam.Handler(a.attach))
-		instance.OnStart(beam.Handler(a.start))
+		instance.OnVerb(beam.Start, beam.Handler(a.start))
-		instance.OnLs(beam.Handler(a.ls))
+		instance.OnVerb(beam.Ls, beam.Handler(a.ls))
 
 		_, err = ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: instance})
 		return err

backends/dockerclient.go

@@ -31,7 +31,7 @@ func DockerClient() beam.Sender {
 
 func DockerClientWithConfig(config *DockerClientConfig) beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		if len(ctx.Args) != 1 {
 			return fmt.Errorf("dockerclient: spawn takes exactly 1 argument, got %d", len(ctx.Args))
 		}
@@ -44,10 +44,10 @@ func DockerClientWithConfig(config *DockerClientConfig) beam.Sender {
 			client: client,
 			Server: beam.NewServer(),
 		}
-		b.Server.OnAttach(beam.Handler(b.attach))
+		b.Server.OnVerb(beam.Attach, beam.Handler(b.attach))
-		b.Server.OnStart(beam.Handler(b.start))
+		b.Server.OnVerb(beam.Start, beam.Handler(b.start))
-		b.Server.OnLs(beam.Handler(b.ls))
+		b.Server.OnVerb(beam.Ls, beam.Handler(b.ls))
-		b.Server.OnSpawn(beam.Handler(b.spawn))
+		b.Server.OnVerb(beam.Spawn, beam.Handler(b.spawn))
 		_, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: b.Server})
 		return err
 	}))
@@ -140,10 +140,10 @@ func (b *dockerClientBackend) spawn(ctx *beam.Message) error {
 func (b *dockerClientBackend) newContainer(id string) beam.Sender {
 	c := &container{backend: b, id: id}
 	instance := beam.NewServer()
-	instance.OnAttach(beam.Handler(c.attach))
+	instance.OnVerb(beam.Attach, beam.Handler(c.attach))
-	instance.OnStart(beam.Handler(c.start))
+	instance.OnVerb(beam.Start, beam.Handler(c.start))
-	instance.OnStop(beam.Handler(c.stop))
+	instance.OnVerb(beam.Stop, beam.Handler(c.stop))
-	instance.OnGet(beam.Handler(c.get))
+	instance.OnVerb(beam.Get, beam.Handler(c.get))
 	return instance
 }
 

backends/dockerserver.go

@@ -22,7 +22,7 @@ import (
 
 func DockerServer() beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		instance := beam.Task(func(in beam.Receiver, out beam.Sender) {
 			url := "tcp://localhost:4243"
 			if len(ctx.Args) > 0 {

backends/exec.go

@@ -14,7 +14,7 @@ import (
 
 func Exec() beam.Sender {
 	e := beam.NewServer()
-	e.OnSpawn(beam.Handler(func(msg *beam.Message) error {
+	e.OnVerb(beam.Spawn, beam.Handler(func(msg *beam.Message) error {
 		if len(msg.Args) < 1 {
 			return fmt.Errorf("usage: SPAWN exec|... <config>")
 		}
@@ -33,7 +33,7 @@ func Exec() beam.Sender {
 			Cmd:	exec.Command(config.Path, config.Args...),
 			Server: beam.NewServer(),
 		}
-		cmd.OnAttach(beam.Handler(func(msg *beam.Message) error {
+		cmd.OnVerb(beam.Attach, beam.Handler(func(msg *beam.Message) error {
 			stdout, err := cmd.StdoutPipe()
 			if err != nil {
 				return err
@@ -76,7 +76,7 @@ func Exec() beam.Sender {
 			cmd.tasks.Wait()
 			return nil
 		}))
-		cmd.OnStart(beam.Handler(func(msg *beam.Message) error {
+		cmd.OnVerb(beam.Start, beam.Handler(func(msg *beam.Message) error {
 			cmd.tasks.Add(1)
 			if err := cmd.Cmd.Start(); err != nil {
 				return err

backends/fakeclient.go

@@ -9,7 +9,7 @@ import (
 
 func FakeClient() beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		// Instantiate a new fakeclient instance
 		instance := beam.Task(func(in beam.Receiver, out beam.Sender) {
 			fmt.Printf("fake client!\n")

backends/orchard.go

@@ -13,7 +13,7 @@ import (
 
 func Orchard() beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		if len(ctx.Args) != 2 {
 			return fmt.Errorf("orchard: spawn expects 2 arguments: API token and name of host")
 		}

backends/shipyard.go

@@ -13,7 +13,7 @@ import (
 
 func Shipyard() beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		if len(ctx.Args) != 3 {
 			return fmt.Errorf("Shipyard: Usage <shipyard URL> <user> <pass>")
 		}
@@ -21,10 +21,10 @@ func Shipyard() beam.Sender {
 		c := &shipyard{url: ctx.Args[0], user: ctx.Args[1], pass: ctx.Args[2]}
 
 		c.Server = beam.NewServer()
-		c.Server.OnAttach(beam.Handler(c.attach))
+		c.Server.OnVerb(beam.Attach, beam.Handler(c.attach))
-		c.Server.OnStart(beam.Handler(c.start))
+		c.Server.OnVerb(beam.Start, beam.Handler(c.start))
-		c.Server.OnLs(beam.Handler(c.containers))
+		c.Server.OnVerb(beam.Ls, beam.Handler(c.containers))
-		c.OnGet(beam.Handler(c.containerInspect))
+		c.OnVerb(beam.Get, beam.Handler(c.containerInspect))
 		_, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: c.Server})
 		return err
 	}))

backends/simulator.go

@@ -6,12 +6,12 @@ import (
 
 func Simulator() beam.Sender {
 	s := beam.NewServer()
-	s.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	s.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		containers := ctx.Args
 		instance := beam.Task(func(in beam.Receiver, out beam.Sender) {
 			beam.Obj(out).Log("[simulator] starting\n")
 			s := beam.NewServer()
-			s.OnLs(beam.Handler(func(msg *beam.Message) error {
+			s.OnVerb(beam.Ls, beam.Handler(func(msg *beam.Message) error {
 				beam.Obj(out).Log("[simulator] generating fake list of objects...\n")
 				beam.Obj(msg.Ret).Set(containers...)
 				return nil

backends/tutum.go

@@ -20,7 +20,7 @@ var (
 
 func Tutum() beam.Sender {
 	backend := beam.NewServer()
-	backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
+	backend.OnVerb(beam.Spawn, beam.Handler(func(ctx *beam.Message) error {
 		if len(ctx.Args) == 2 {
 			tutum.User = ctx.Args[0]
 			tutum.ApiKey = ctx.Args[1]
@@ -36,10 +36,10 @@ func Tutum() beam.Sender {
 			tutumDockerConnector: tutumDockerConnector,
 			Server:               beam.NewServer(),
 		}
-		t.Server.OnAttach(beam.Handler(t.attach))
+		t.Server.OnVerb(beam.Attach, beam.Handler(t.attach))
-		t.Server.OnStart(beam.Handler(t.ack))
+		t.Server.OnVerb(beam.Start, beam.Handler(t.ack))
-		t.Server.OnLs(beam.Handler(t.ls))
+		t.Server.OnVerb(beam.Ls, beam.Handler(t.ls))
-		t.Server.OnSpawn(beam.Handler(t.spawn))
+		t.Server.OnVerb(beam.Spawn, beam.Handler(t.spawn))
 		_, err = ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: t.Server})
 		return err
 	}))
@@ -121,9 +121,9 @@ func (t *tutumBackend) spawn(ctx *beam.Message) error {
 func (t *tutumBackend) newContainer(id string) beam.Sender {
 	c := &tutumContainer{tutumBackend: t, id: id}
 	instance := beam.NewServer()
-	instance.OnGet(beam.Handler(c.get))
+	instance.OnVerb(beam.Get, beam.Handler(c.get))
-	instance.OnStart(beam.Handler(c.start))
+	instance.OnVerb(beam.Start, beam.Handler(c.start))
-	instance.OnStop(beam.Handler(c.stop))
+	instance.OnVerb(beam.Stop, beam.Handler(c.stop))
 	return instance
 }
 

beam/server.go

@@ -27,38 +27,6 @@ func (s *Server) OnVerb(v Verb, h Sender) *Server {
 	return s
 }
 
-func (s *Server) OnSpawn(h Sender) *Server {
-	return s.OnVerb(Spawn, h)
-}
-
-func (s *Server) OnStart(h Sender) *Server {
-	return s.OnVerb(Start, h)
-}
-
-func (s *Server) OnStop(h Sender) *Server {
-	return s.OnVerb(Stop, h)
-}
-
-func (s *Server) OnAttach(h Sender) *Server {
-	return s.OnVerb(Attach, h)
-}
-
-func (s *Server) OnLog(h Sender) *Server {
-	return s.OnVerb(Log, h)
-}
-
-func (s *Server) OnError(h Sender) *Server {
-	return s.OnVerb(Error, h)
-}
-
-func (s *Server) OnLs(h Sender) *Server {
-	return s.OnVerb(Ls, h)
-}
-
-func (s *Server) OnGet(h Sender) *Server {
-	return s.OnVerb(Get, h)
-}
-
 func (s *Server) Send(msg *Message) (Receiver, error) {
 	if h, exists := s.handlers[msg.Verb]; exists {
 		return h.Send(msg)

beam/task.go

@@ -11,14 +11,14 @@ func Task(f func(in Receiver, out Sender)) Sender {
 	inR, inW := Pipe()
 	outR, outW := Pipe()
 	obj := NewServer()
-	obj.OnAttach(Handler(func(msg *Message) error {
+	obj.OnVerb(Attach, Handler(func(msg *Message) error {
 		msg.Ret.Send(&Message{Verb: Ack, Ret: inW})
 		fmt.Printf("copying task output from %#v to %#v\n", outR, msg.Ret)
 		defer fmt.Printf("(DONE) copying task output from %#v to %#v\n", outR, msg.Ret)
 		Copy(msg.Ret, outR)
 		return nil
 	}))
-	obj.OnStart(Handler(func(msg *Message) error {
+	obj.OnVerb(Start, Handler(func(msg *Message) error {
 		l.RLock()
 		r := running
 		l.RUnlock()

beam/tree.go

@@ -14,7 +14,7 @@ func NewTree() *Tree {
 		Server:   NewServer(),
 		children: make(map[string]Sender),
 	}
-	t.OnAttach(Handler(func(msg *Message) error {
+	t.OnVerb(Attach, Handler(func(msg *Message) error {
 		if len(msg.Args) == 0 || msg.Args[0] == "" {
 			msg.Ret.Send(&Message{Verb: Ack, Ret: t})
 			return nil
@@ -26,7 +26,7 @@ func NewTree() *Tree {
 		Obj(msg.Ret).Error("not found")
 		return nil
 	}))
-	t.OnLs(Handler(func(msg *Message) error {
+	t.OnVerb(Ls, Handler(func(msg *Message) error {
 		names := make([]string, 0, len(t.children))
 		for name := range t.children {
 			names = append(names, name)

debug/debug.go

@@ -15,7 +15,7 @@ func Debug() beam.Sender {
 	}
 
 	sender := beam.NewServer()
-	sender.OnSpawn(beam.Handler(dbgInstance.spawn))
+	sender.OnVerb(beam.Spawn, beam.Handler(dbgInstance.spawn))
 	return sender
 }