docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename forward backend to dockerclient 

Signed-off-by: Ben Firshman <ben@firshman.co.uk>
This commit is contained in:
Ben Firshman 2014-06-08 16:34:46 -07:00
parent a74d45d360
commit 2a8eab0cd3
3 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backends/backends.go
View File

@ -15,7 +15,7 @@ func New() *beam.Object {
backends.Bind("simulator", Simulator()) backends.Bind("simulator", Simulator())
backends.Bind("debug", Debug()) backends.Bind("debug", Debug())
backends.Bind("fakeclient", FakeClient()) backends.Bind("fakeclient", FakeClient())
backends.Bind("forward", Forward()) backends.Bind("dockerclient", DockerClient())
backends.Bind("exec", Exec()) backends.Bind("exec", Exec())
backends.Bind("dockerserver", DockerServer()) backends.Bind("dockerserver", DockerServer())
backends.Bind("orchard", Orchard()) backends.Bind("orchard", Orchard())

64
backends/forward.go → backends/dockerclient.go
View File

@ -17,59 +17,59 @@ import (
"time" "time"
) )
type ForwardConfig struct { type DockerClientConfig struct {
Scheme string Scheme string
URLHost string URLHost string
TLSClientConfig *tls.Config TLSClientConfig *tls.Config
} }
func Forward() beam.Sender { func DockerClient() beam.Sender {
return ForwardWithConfig(&ForwardConfig{ return DockerClientWithConfig(&DockerClientConfig{
Scheme: "http", Scheme: "http",
URLHost: "dummy.host", URLHost: "dummy.host",
}) })
} }
func ForwardWithConfig(config *ForwardConfig) beam.Sender { func DockerClientWithConfig(config *DockerClientConfig) beam.Sender {
backend := beam.NewServer() backend := beam.NewServer()
backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error { backend.OnSpawn(beam.Handler(func(ctx *beam.Message) error {
if len(ctx.Args) != 1 { if len(ctx.Args) != 1 {
return fmt.Errorf("forward: spawn takes exactly 1 argument, got %d", len(ctx.Args)) return fmt.Errorf("dockerclient: spawn takes exactly 1 argument, got %d", len(ctx.Args))
} }
client := newClient() client := newClient()
client.scheme = config.Scheme client.scheme = config.Scheme
client.urlHost = config.URLHost client.urlHost = config.URLHost
client.transport.TLSClientConfig = config.TLSClientConfig client.transport.TLSClientConfig = config.TLSClientConfig
client.setURL(ctx.Args[0]) client.setURL(ctx.Args[0])
f := &forwarder{ b := &dockerClientBackend{
client: client, client: client,
Server: beam.NewServer(), Server: beam.NewServer(),
} }
f.Server.OnAttach(beam.Handler(f.attach)) b.Server.OnAttach(beam.Handler(b.attach))
f.Server.OnStart(beam.Handler(f.start)) b.Server.OnStart(beam.Handler(b.start))
f.Server.OnLs(beam.Handler(f.ls)) b.Server.OnLs(beam.Handler(b.ls))
f.Server.OnSpawn(beam.Handler(f.spawn)) b.Server.OnSpawn(beam.Handler(b.spawn))
_, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: f.Server}) _, err := ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: b.Server})
return err return err
})) }))
return backend return backend
} }
type forwarder struct { type dockerClientBackend struct {
client *client client *client
*beam.Server *beam.Server
} }
func (f *forwarder) attach(ctx *beam.Message) error { func (b *dockerClientBackend) attach(ctx *beam.Message) error {
if ctx.Args[0] == "" { if ctx.Args[0] == "" {
ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: f.Server}) ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: b.Server})
for { for {
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
(&beam.Object{ctx.Ret}).Log("forward: heartbeat") (&beam.Object{ctx.Ret}).Log("dockerclient: heartbeat")
} }
} else { } else {
path := fmt.Sprintf("/containers/%s/json", ctx.Args[0]) path := fmt.Sprintf("/containers/%s/json", ctx.Args[0])
resp, err := f.client.call("GET", path, "") resp, err := b.client.call("GET", path, "")
if err != nil { if err != nil {
return err return err
} }
@ -80,19 +80,19 @@ func (f *forwarder) attach(ctx *beam.Message) error {
if resp.StatusCode != 200 { if resp.StatusCode != 200 {
return fmt.Errorf("%s", respBody) return fmt.Errorf("%s", respBody)
} }
c := f.newContainer(ctx.Args[0]) c := b.newContainer(ctx.Args[0])
ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: c}) ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: c})
} }
return nil return nil
} }
func (f *forwarder) start(ctx *beam.Message) error { func (b *dockerClientBackend) start(ctx *beam.Message) error {
ctx.Ret.Send(&beam.Message{Verb: beam.Ack}) ctx.Ret.Send(&beam.Message{Verb: beam.Ack})
return nil return nil
} }
func (f *forwarder) ls(ctx *beam.Message) error { func (b *dockerClientBackend) ls(ctx *beam.Message) error {
resp, err := f.client.call("GET", "/containers/json", "") resp, err := b.client.call("GET", "/containers/json", "")
if err != nil { if err != nil {
return fmt.Errorf("get: %v", err) return fmt.Errorf("get: %v", err)
} }
@ -115,11 +115,11 @@ func (f *forwarder) ls(ctx *beam.Message) error {
return nil return nil
} }
func (f *forwarder) spawn(ctx *beam.Message) error { func (b *dockerClientBackend) spawn(ctx *beam.Message) error {
if len(ctx.Args) != 1 { if len(ctx.Args) != 1 {
return fmt.Errorf("forward: spawn takes exactly 1 argument, got %d", len(ctx.Args)) return fmt.Errorf("dockerclient: spawn takes exactly 1 argument, got %d", len(ctx.Args))
} }
resp, err := f.client.call("POST", "/containers/create", ctx.Args[0]) resp, err := b.client.call("POST", "/containers/create", ctx.Args[0])
if err != nil { if err != nil {
return err return err
} }
@ -134,15 +134,15 @@ func (f *forwarder) spawn(ctx *beam.Message) error {
if err = json.Unmarshal(respBody, &respJson); err != nil { if err = json.Unmarshal(respBody, &respJson); err != nil {
return err return err
} }
c := f.newContainer(respJson.Id) c := b.newContainer(respJson.Id)
if _, err = ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: c}); err != nil { if _, err = ctx.Ret.Send(&beam.Message{Verb: beam.Ack, Ret: c}); err != nil {
return err return err
} }
return nil return nil
} }
func (f *forwarder) newContainer(id string) beam.Sender { func (b *dockerClientBackend) newContainer(id string) beam.Sender {
c := &container{forwarder: f, id: id} c := &container{backend: b, id: id}
instance := beam.NewServer() instance := beam.NewServer()
instance.OnAttach(beam.Handler(c.attach)) instance.OnAttach(beam.Handler(c.attach))
instance.OnStart(beam.Handler(c.start)) instance.OnStart(beam.Handler(c.start))
@ -152,8 +152,8 @@ func (f *forwarder) newContainer(id string) beam.Sender {
} }
type container struct { type container struct {
forwarder *forwarder backend *dockerClientBackend
id string id string
} }
func (c *container) attach(ctx *beam.Message) error { func (c *container) attach(ctx *beam.Message) error {
@ -167,7 +167,7 @@ func (c *container) attach(ctx *beam.Message) error {
stderrR, stderrW := io.Pipe() stderrR, stderrW := io.Pipe()
go copyOutput(ctx.Ret, stdoutR, "stdout") go copyOutput(ctx.Ret, stdoutR, "stdout")
go copyOutput(ctx.Ret, stderrR, "stderr") go copyOutput(ctx.Ret, stderrR, "stderr")
c.forwarder.client.hijack("POST", path, nil, stdoutW, stderrW) c.backend.client.hijack("POST", path, nil, stdoutW, stderrW)
return nil return nil
} }
@ -189,7 +189,7 @@ func copyOutput(sender beam.Sender, reader io.Reader, tag string) {
func (c *container) start(ctx *beam.Message) error { func (c *container) start(ctx *beam.Message) error {
path := fmt.Sprintf("/containers/%s/start", c.id) path := fmt.Sprintf("/containers/%s/start", c.id)
resp, err := c.forwarder.client.call("POST", path, "{}") resp, err := c.backend.client.call("POST", path, "{}")
if err != nil { if err != nil {
return err return err
} }
@ -208,7 +208,7 @@ func (c *container) start(ctx *beam.Message) error {
func (c *container) stop(ctx *beam.Message) error { func (c *container) stop(ctx *beam.Message) error {
path := fmt.Sprintf("/containers/%s/stop", c.id) path := fmt.Sprintf("/containers/%s/stop", c.id)
resp, err := c.forwarder.client.call("POST", path, "{}") resp, err := c.backend.client.call("POST", path, "{}")
if err != nil { if err != nil {
return err return err
} }
@ -227,7 +227,7 @@ func (c *container) stop(ctx *beam.Message) error {
func (c *container) get(ctx *beam.Message) error { func (c *container) get(ctx *beam.Message) error {
path := fmt.Sprintf("/containers/%s/json", c.id) path := fmt.Sprintf("/containers/%s/json", c.id)
resp, err := c.forwarder.client.call("GET", path, "") resp, err := c.backend.client.call("GET", path, "")
if err != nil { if err != nil {
return err return err
} }

2
backends/orchard.go
View File

@ -35,7 +35,7 @@ func Orchard() beam.Sender {
return err return err
} }
backend := ForwardWithConfig(&ForwardConfig{ backend := DockerClientWithConfig(&DockerClientConfig{
Scheme: "https", Scheme: "https",
URLHost: host.IPAddress, URLHost: host.IPAddress,
TLSClientConfig: tlsConfig, TLSClientConfig: tlsConfig,