// Installs the RaxCloud backend into an engine func (rax *RaxCloud) Install(eng *engine.Engine) (err error) { eng.Register("rax", func(job *engine.Job) (status engine.Status) { return rax.init(job) }) return nil }
func Register(eng *engine.Engine) error { if err := daemon(eng); err != nil { return err } if err := remote(eng); err != nil { return err } if err := eng.Register("version", dockerVersion); err != nil { return err } return registry.NewService().Install(eng) }
func (s *TagStore) Install(eng *engine.Engine) error { eng.Register("image_set", s.CmdSet) eng.Register("image_tag", s.CmdTag) eng.Register("image_get", s.CmdGet) eng.Register("image_inspect", s.CmdLookup) eng.Register("image_tarlayer", s.CmdTarLayer) return nil }
// daemon: a default execution and storage backend for Docker on Linux, // with the following underlying components: // // * Pluggable storage drivers including aufs, vfs, lvm and btrfs. // * Pluggable execution drivers including lxc and chroot. // // In practice `daemon` still includes most core Docker components, including: // // * The reference registry client implementation // * Image management // * The build facility // * Logging // // These components should be broken off into plugins of their own. // func daemon(eng *engine.Engine) error { if err := eng.Register("initserverpidfile", server.InitPidfile); err != nil { return err } if err := eng.Register("initserver", server.InitServer); err != nil { return err } return eng.Register("init_networkdriver", bridge.InitDriver) }
// Install installs daemon capabilities to eng. func (daemon *Daemon) Install(eng *engine.Engine) error { return eng.Register("container_inspect", daemon.ContainerInspect) }
// daemon: a default execution and storage backend for Docker on Linux, // with the following underlying components: // // * Pluggable storage drivers including aufs, vfs, lvm and btrfs. // * Pluggable execution drivers including lxc and chroot. // // In practice `daemon` still includes most core Docker components, including: // // * The reference registry client implementation // * Image management // * The build facility // * Logging // // These components should be broken off into plugins of their own. // func daemon(eng *engine.Engine) { eng.Register("initserver", server.InitServer) eng.Register("init_networkdriver", lxc.InitDriver) }
// remote: a RESTful api for cross-docker communication func remote(eng *engine.Engine) { eng.Register("serveapi", api.ServeApi) }
// remote: a RESTful api for cross-docker communication func remote(eng *engine.Engine) error { if err := eng.Register("serveapi", apiserver.ServeApi); err != nil { return err } return eng.Register("acceptconnections", apiserver.AcceptConnections) }
func (t *tutumBackend) Install(eng *engine.Engine) error { eng.Register("tutum", func(job *engine.Job) engine.Status { if len(job.Args) == 1 { tutumConnector = job.Args[0] } if !tutum.IsAuthenticated() { return job.Errorf("You need to provide your Tutum credentials in ~/.tutum or environment variables TUTUM_USER and TUTUM_APIKEY") } job.Eng.Register("containers", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/json?all=%s&limit=%s", url.QueryEscape(job.Getenv("all")), url.QueryEscape(job.Getenv("limit")), ) resp, err := tutumConnectorCall("GET", path, "") if err != nil { return job.Errorf("%s: get: %v", path, err) } c := engine.NewTable("Created", 0) body, err := ioutil.ReadAll(resp.Body) if err != nil { return job.Errorf("%s: read body: %v", path, err) } if _, err := c.ReadListFrom(body); err != nil { return job.Errorf("%s: readlist: %v", path, err) } c.WriteListTo(job.Stdout) return engine.StatusOK }) job.Eng.Register("create", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/create", ) config := runconfig.ContainerConfigFromJob(job) data, err := json.Marshal(config) if err != nil { return job.Errorf("%s: json marshal: %v", path, err) } resp, err := tutumConnectorCall("POST", path, string(data)) if err != nil { return job.Errorf("%s: post: %v", path, err) } body, err := ioutil.ReadAll(resp.Body) if err != nil { return job.Errorf("%s: read body: %#v", path, err) } var containerOut struct { Id string Warnings []string } err = json.Unmarshal([]byte(body), &containerOut) _, err = job.Printf("%s\n", containerOut.Id) if err != nil { return job.Errorf("%s: write body: %#v", path, err) } log.Printf("%s", string(body)) return engine.StatusOK }) job.Eng.Register("container_delete", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/%s?force=%s", job.Args[0], url.QueryEscape(job.Getenv("forceRemove")), ) _, err := tutumConnectorCall("DELETE", path, "") if err != nil { return job.Errorf("%s: delete: %v", path, err) } return engine.StatusOK }) job.Eng.Register("start", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf("/containers/%s/start", job.Args[0]) config := runconfig.ContainerConfigFromJob(job) data, err := json.Marshal(config) if err != nil { return job.Errorf("%s: json marshal: %v", path, err) } _, err = tutumConnectorCall("POST", path, string(data)) if err != nil { return job.Errorf("%s: post: %v", path, err) } return engine.StatusOK }) job.Eng.Register("stop", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/%s/stop?t=%s", job.Args[0], url.QueryEscape(job.Getenv("t")), ) _, err := tutumConnectorCall("POST", path, "") if err != nil { return job.Errorf("%s: post: %v", path, err) } return engine.StatusOK }) job.Eng.Register("kill", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/%s/kill?signal=%s", job.Args[0], job.Args[1], ) _, err := tutumConnectorCall("POST", path, "") if err != nil { return job.Errorf("%s: post: %v", path, err) } return engine.StatusOK }) job.Eng.Register("restart", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/%s/restart?t=%s", job.Args[0], url.QueryEscape(job.Getenv("t")), ) _, err := tutumConnectorCall("POST", path, "") if err != nil { return job.Errorf("%s: post: %v", path, err) } return engine.StatusOK }) job.Eng.Register("inspect", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/%s/json", job.Args[0], ) resp, err := tutumConnectorCall("GET", path, "") if err != nil { return job.Errorf("%s: get: %v", path, err) } _, err = io.Copy(job.Stdout, resp.Body) if err != nil { return job.Errorf("%s: copy stream: %v", path, err) } return engine.StatusOK }) job.Eng.Register("logs", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := fmt.Sprintf( "/containers/%s/logs?stdout=%s&stderr=%s", job.Args[0], url.QueryEscape(job.Getenv("stdout")), url.QueryEscape(job.Getenv("stderr")), ) resp, err := tutumConnectorCall("GET", path, "") if err != nil { return job.Errorf("%s: get: %v", path, err) } _, err = io.Copy(job.Stdout, resp.Body) if err != nil { return job.Errorf("%s: copy stream: %v", path, err) } return engine.StatusOK }) job.Eng.Register("version", func(job *engine.Job) engine.Status { log.Printf("Received '%s' operation....", job.Name) path := "/version" resp, err := tutumConnectorCall("GET", path, "") if err != nil { return job.Errorf("%s: get: %v", path, err) } _, err = io.Copy(job.Stdout, resp.Body) if err != nil { return job.Errorf("%s: copy stream: %v", path, err) } return engine.StatusOK }) job.Eng.RegisterCatchall(func(job *engine.Job) engine.Status { return job.Errorf("Operation not yet supported: %s", job.Name) }) return engine.StatusOK }) return nil }
func (s *cloud) Install(eng *engine.Engine) error { eng.Register("cloud", func(job *engine.Job) engine.Status { if len(job.Args) < 3 { return job.Errorf("usage: %s <provider> <instance> <zone> <aditional> <provider> <args> <proto>://<addr>", job.Name) } instance := job.Args[1] zone := job.Args[2] var cloud Cloud var err error switch job.Args[0] { case "gce": if len(job.Args) < 4 { return job.Errorf("usage: %s gce <instance> <zone> <project>") } cloud, err = NewCloudGCE(job.Args[3]) if err != nil { return job.Errorf("Unexpected error: %#v", err) } default: return job.Errorf("Unknown cloud provider: %s", job.Args[0]) } ip, err := cloud.GetPublicIPAddress(instance, zone) instanceRunning := len(ip) > 0 if !instanceRunning { log.Print("Instance doesn't exist, creating....") _, err = cloud.CreateInstance(instance, zone) } if err != nil { return job.Errorf("Unexpected error: %#v", err) } remotePort := 8000 localPort := 8001 apiVersion := "v1.10" tunnelUrl, err := url.Parse(fmt.Sprintf("http://localhost:%d/%s/containers/json", localPort, apiVersion)) if err != nil { return job.Errorf("Unexpected error: %#v", err) } tunnel := Tunnel{*tunnelUrl} if !tunnel.isActive() { fmt.Printf("Creating tunnel") _, err = cloud.OpenSecureTunnel(instance, zone, localPort, remotePort) if err != nil { return job.Errorf("Failed to open tunnel: %#v", err) } } host := fmt.Sprintf("tcp://localhost:%d", localPort) client := newClient() client.setURL(host) client.version = apiVersion //job.Eng.Register("inspect", func(job *engine.Job) engine.Status { // resp, err := client.call("GET", "/containers/ job.Eng.Register("create", func(job *engine.Job) engine.Status { container := Container{ Image: job.Getenv("Image"), Tty: job.Getenv("Tty") == "true", } data, err := json.Marshal(container) resp, err := client.call("POST", "/containers/create", string(data)) if err != nil { return job.Errorf("post: %v", err) } body, err := ioutil.ReadAll(resp.Body) if err != nil { return job.Errorf("read body: %#v", err) } var containerOut Container err = json.Unmarshal([]byte(body), &containerOut) _, err = job.Printf("%s\n", containerOut.Id) if err != nil { return job.Errorf("write body: %#v", err) } log.Printf("%s", string(body)) return engine.StatusOK }) job.Eng.Register("start", func(job *engine.Job) engine.Status { path := fmt.Sprintf("/containers/%s/start", job.Args[0]) resp, err := client.call("POST", path, "{\"Binds\":[],\"ContainerIDFile\":\"\",\"LxcConf\":[],\"Privileged\":false,\"PortBindings\":{},\"Links\":null,\"PublishAllPorts\":false,\"Dns\":null,\"DnsSearch\":[],\"VolumesFrom\":[]}") if err != nil { return job.Errorf("post: %v", err) } body, err := ioutil.ReadAll(resp.Body) if err != nil { return job.Errorf("read body: %#v", err) } log.Printf("%s", string(body)) return engine.StatusOK }) job.Eng.Register("containers", func(job *engine.Job) engine.Status { path := fmt.Sprintf( "/containers/json?all=%s&size=%s&since=%s&before=%s&limit=%s", url.QueryEscape(job.Getenv("all")), url.QueryEscape(job.Getenv("size")), url.QueryEscape(job.Getenv("since")), url.QueryEscape(job.Getenv("before")), url.QueryEscape(job.Getenv("limit")), ) resp, err := client.call("GET", path, "") if err != nil { return job.Errorf("get: %v", err) } // FIXME: check for response error c := engine.NewTable("Created", 0) body, err := ioutil.ReadAll(resp.Body) if err != nil { return job.Errorf("read body: %v", err) } fmt.Printf("---> '%s'\n", body) if _, err := c.ReadListFrom(body); err != nil { return job.Errorf("readlist: %v", err) } c.WriteListTo(job.Stdout) return engine.StatusOK }) job.Eng.Register("container_delete", func(job *engine.Job) engine.Status { log.Printf("%#v", job.Args) path := "/containers/" + job.Args[0] resp, err := client.call("DELETE", path, "") if err != nil { return job.Errorf("delete: %v", err) } log.Printf("%#v", resp) return engine.StatusOK }) job.Eng.Register("stop", func(job *engine.Job) engine.Status { log.Printf("%#v", job.Args) path := "/containers/" + job.Args[0] + "/stop" resp, err := client.call("POST", path, "") if err != nil { return job.Errorf("delete: %v", err) } log.Printf("%#v", resp) return engine.StatusOK }) job.Eng.RegisterCatchall(func(job *engine.Job) engine.Status { log.Printf("%#v %#v %#v", *job, job.Env(), job.Args) return engine.StatusOK }) return engine.StatusOK }) return nil }
// Install installs registry capabilities to eng. func (s *Service) Install(eng *engine.Engine) error { eng.Register("auth", s.Auth) eng.Register("search", s.Search) return nil }
func (s *TagStore) Install(eng *engine.Engine) error { eng.Register("image_set", s.CmdSet) eng.Register("image_tag", s.CmdTag) eng.Register("image_get", s.CmdGet) return nil }
// daemon: a default execution and storage backend for Docker on Linux, // with the following underlying components: // // * Pluggable storage drivers including aufs, vfs, lvm and btrfs. // * Pluggable execution drivers including lxc and chroot. // // In practice `daemon` still includes most core Docker components, including: // // * The reference registry client implementation // * Image management // * The build facility // * Logging // // These components should be broken off into plugins of their own. // func daemon(eng *engine.Engine) { eng.Register("initserver", docker.InitServer) eng.Register("init_networkdriver", lxc.InitDriver) eng.Register("version", docker.GetVersion) }
func (w *Worker) Install(eng *engine.Engine) error { eng.Register("exec", w.Exec) eng.Register("cd", w.Cd) eng.Register("echo", w.Echo) return nil }
// remote: a RESTful api for cross-docker communication func remote(eng *engine.Engine) error { return eng.Register("serveapi", api.ServeApi) }
func (rax *RaxCloud) run(ctx *cli.Context, eng *engine.Engine) (err error) { if err = rax.configure(ctx); err == nil { if _, name, err := rax.findTargetHost(); err == nil { if name == "" { rax.createHost(DASS_TARGET_PREFIX + RandomString()[:12]) } } else { return err } eng.Register("create", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := "/containers/create" config := runconfig.ContainerConfigFromJob(job) if data, err := json.Marshal(config); err != nil { return job.Errorf("marshaling failure : %v", err) } else if resp, err := client.Post(path, string(data)); err != nil { return job.Error(err) } else { var container struct { Id string Warnings []string } if body, err := ioutil.ReadAll(resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } else if err := json.Unmarshal([]byte(body), &container); err != nil { return job.Errorf("Failed to read container info from body: %v", err) } else { job.Printf("%s\n", container.Id) } } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("container_delete", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s?force=%s", job.Args[0], url.QueryEscape(job.Getenv("forceRemove"))) if _, err := client.Delete(path, ""); err != nil { return job.Error(err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("containers", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/json?all=%s&limit=%s", url.QueryEscape(job.Getenv("all")), url.QueryEscape(job.Getenv("limit"))) if resp, err := client.Get(path, ""); err != nil { return job.Error(err) } else { created := engine.NewTable("Created", 0) if body, err := ioutil.ReadAll(resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } else if created.ReadListFrom(body); err != nil { return job.Errorf("Failed to read list from body: %v", err) } else { created.WriteListTo(job.Stdout) } } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("version", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := "/version" if resp, err := client.Get(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } else if _, err := io.Copy(job.Stdout, resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("start", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/start", job.Args[0]) config := runconfig.ContainerConfigFromJob(job) if data, err := json.Marshal(config); err != nil { return job.Errorf("marshaling failure : %v", err) } else if _, err := client.Post(path, string(data)); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("stop", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/stop?t=%s", job.Args[0], url.QueryEscape(job.Getenv("t"))) if _, err := client.Post(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("kill", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/kill?signal=%s", job.Args[0], job.Args[1]) if _, err := client.Post(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("restart", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/restart?t=%s", url.QueryEscape(job.Getenv("t"))) if _, err := client.Post(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("inspect", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/json", job.Args[0]) if resp, err := client.Post(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } else if _, err := io.Copy(job.Stdout, resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("attach", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/attach?stream=%s&stdout=%s&stderr=%s", job.Args[0], url.QueryEscape(job.Getenv("stream")), url.QueryEscape(job.Getenv("stdout")), url.QueryEscape(job.Getenv("stderr"))) if resp, err := client.Post(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } else if _, err := io.Copy(job.Stdout, resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("pull", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/images/create?fromImage=%s&tag=%s", job.Args[0], url.QueryEscape(job.Getenv("tag"))) if resp, err := client.Post(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } else if _, err := io.Copy(job.Stdout, resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.Register("logs", func(job *engine.Job) (status engine.Status) { if ctx, err := rax.getHostContext(); err == nil { defer ctx.Close() return ctx.exec(job, func(client HttpClient) (status engine.Status) { path := fmt.Sprintf("/containers/%s/logs?stdout=%s&stderr=%s", job.Args[0], url.QueryEscape(job.Getenv("stdout")), url.QueryEscape(job.Getenv("stderr"))) if resp, err := client.Get(path, ""); err != nil { return job.Errorf("Failed call %s(path:%s): %v", job.Name, path, err) } else if _, err := io.Copy(job.Stdout, resp.Body); err != nil { return job.Errorf("Failed to copy response body: %v", err) } return engine.StatusOK }) } else { return job.Errorf("Failed to create host context: %v", err) } }) eng.RegisterCatchall(func(job *engine.Job) engine.Status { log.Printf("[UNIMPLEMENTED] %s %#v %#v %#v", job.Name, *job, job.Env(), job.Args) return engine.StatusOK }) } return err }