func DockerServer() beam.Sender {
backend := beam.NewServer()
backend.OnSpawn(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 {
url = ctx.Args[0]
}
err := listenAndServe(url, out)
if err != nil {
fmt.Printf("listenAndServe: %v", err)
}
})
_, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: instance})
return err
}))
return backend
}
func Simulator() beam.Sender {
s := beam.NewServer()
s.OnSpawn(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 {
beam.Obj(out).Log("[simulator] generating fake list of objects...\n")
beam.Obj(msg.Ret).Set(containers...)
return nil
}))
beam.Copy(s, in)
})
ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: instance})
return nil
}))
return s
}
func FakeClient() beam.Sender {
backend := beam.NewServer()
backend.OnSpawn(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")
defer fmt.Printf("end of fake client!\n")
o := beam.Obj(out)
o.Log("fake client starting")
defer o.Log("fake client terminating")
for {
time.Sleep(1 * time.Second)
o.Log("fake client heartbeat!")
}
})
_, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: instance})
return err
}))
return backend
}
func Debug() beam.Sender {
backend := beam.NewServer()
backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
instance := beam.Task(func(in beam.Receiver, out beam.Sender) {
for {
msg, err := in.Receive(beam.Ret)
if err != nil {
fmt.Printf("debug receive: %v", err)
return
}
fmt.Printf("[DEBUG] %s %s\n", msg.Verb, strings.Join(msg.Args, " "))
if _, err := out.Send(msg); err != nil {
fmt.Printf("debug send: %v", err)
return
}
}
})
_, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: instance})
return err
}))
return backend
}
// Spawn will return a new instance as the Ret channel of the message sent back
func (dbg *debug) spawn(msg *beam.Message) (err error) {
// By sending back a task, beam will run the function with the in and out arguments
// set to the services present before and after this one in the pipeline.
instance := beam.Task(func(in beam.Receiver, out beam.Sender) {
// Setup our channels
dbg.in = in
dbg.out = out
// Set up the debug interceptor
dbg.service.Catchall(beam.Handler(dbg.catchall))
// Copy everything from the receiver to our service. By copying like this in the task
// we can use the catchall handler instead of handling the message here.
beam.Copy(dbg.service, in)
})
// Inform the system of our new instance
msg.Ret.Send(&beam.Message{
Verb: beam.Ack,
Ret: instance,
})
return
}