// ImageSearch makes the docker host to search by a term in a remote registry. // The list of results is not sorted in any fashion. func (cli *Client) ImageSearch(ctx context.Context, term string, options types.ImageSearchOptions) ([]registry.SearchResult, error) { var results []registry.SearchResult query := url.Values{} query.Set("term", term) if options.Filters.Len() > 0 { filterJSON, err := filters.ToParam(options.Filters) if err != nil { return results, err } query.Set("filters", filterJSON) } resp, err := cli.tryImageSearch(ctx, query, options.RegistryAuth) if resp.statusCode == http.StatusUnauthorized && options.PrivilegeFunc != nil { newAuthHeader, privilegeErr := options.PrivilegeFunc() if privilegeErr != nil { return results, privilegeErr } resp, err = cli.tryImageSearch(ctx, query, newAuthHeader) } if err != nil { return results, err } err = json.NewDecoder(resp.body).Decode(&results) ensureReaderClosed(resp) return results, err }
func (o *FilterOpt) String() string { repr, err := filters.ToParam(o.filter) if err != nil { return "invalid filters" } return repr }
// Events returns a stream of events in the daemon in a ReadCloser. // It's up to the caller to close the stream. func (cli *Client) Events(ctx context.Context, options types.EventsOptions) (io.ReadCloser, error) { query := url.Values{} ref := time.Now() if options.Since != "" { ts, err := timetypes.GetTimestamp(options.Since, ref) if err != nil { return nil, err } query.Set("since", ts) } if options.Until != "" { ts, err := timetypes.GetTimestamp(options.Until, ref) if err != nil { return nil, err } query.Set("until", ts) } if options.Filters.Len() > 0 { filterJSON, err := filters.ToParam(options.Filters) if err != nil { return nil, err } query.Set("filters", filterJSON) } serverResponse, err := cli.get(ctx, "/events", query, nil) if err != nil { return nil, err } return serverResponse.body, nil }
// ImageList returns a list of images in the docker host. func (cli *Client) ImageList(options types.ImageListOptions) ([]types.Image, error) { var images []types.Image query := url.Values{} if options.Filters.Len() > 0 { filterJSON, err := filters.ToParam(options.Filters) if err != nil { return images, err } query.Set("filters", filterJSON) } if options.MatchName != "" { // FIXME rename this parameter, to not be confused with the filters flag query.Set("filter", options.MatchName) } if options.All { query.Set("all", "1") } serverResp, err := cli.get("/images/json", query, nil) if err != nil { return images, err } err = json.NewDecoder(serverResp.body).Decode(&images) ensureReaderClosed(serverResp) return images, err }
func (d *SwarmDaemon) getServiceTasks(c *check.C, service string) []swarm.Task { var tasks []swarm.Task filterArgs := filters.NewArgs() filterArgs.Add("desired-state", "running") filterArgs.Add("service", service) filters, err := filters.ToParam(filterArgs) c.Assert(err, checker.IsNil) status, out, err := d.SockRequest("GET", "/tasks?filters="+filters, nil) c.Assert(status, checker.Equals, http.StatusOK, check.Commentf("output: %q", string(out))) c.Assert(err, checker.IsNil, check.Commentf(string(out))) c.Assert(json.Unmarshal(out, &tasks), checker.IsNil) return tasks }
// NetworkList returns the list of networks configured in the docker host. func (cli *Client) NetworkList(ctx context.Context, options types.NetworkListOptions) ([]types.NetworkResource, error) { query := url.Values{} if options.Filters.Len() > 0 { filterJSON, err := filters.ToParam(options.Filters) if err != nil { return nil, err } query.Set("filters", filterJSON) } var networkResources []types.NetworkResource resp, err := cli.get(ctx, "/networks", query, nil) if err != nil { return networkResources, err } err = json.NewDecoder(resp.body).Decode(&networkResources) ensureReaderClosed(resp) return networkResources, err }
// ContainerList returns the list of containers in the docker host. func (cli *Client) ContainerList(options types.ContainerListOptions) ([]types.Container, error) { query := url.Values{} if options.All { query.Set("all", "1") } if options.Limit != -1 { query.Set("limit", strconv.Itoa(options.Limit)) } if options.Since != "" { query.Set("since", options.Since) } if options.Before != "" { query.Set("before", options.Before) } if options.Size { query.Set("size", "1") } if options.Filter.Len() > 0 { filterJSON, err := filters.ToParam(options.Filter) if err != nil { return nil, err } query.Set("filters", filterJSON) } resp, err := cli.get("/containers/json", query, nil) if err != nil { return nil, err } var containers []types.Container err = json.NewDecoder(resp.body).Decode(&containers) ensureReaderClosed(resp) return containers, err }
// VolumeList returns the volumes configured in the docker host. func (cli *Client) VolumeList(ctx context.Context, filter filters.Args) (types.VolumesListResponse, error) { var volumes types.VolumesListResponse query := url.Values{} if filter.Len() > 0 { filterJSON, err := filters.ToParam(filter) if err != nil { return volumes, err } query.Set("filters", filterJSON) } resp, err := cli.get(ctx, "/volumes", query, nil) if err != nil { return volumes, err } err = json.NewDecoder(resp.body).Decode(&volumes) ensureReaderClosed(resp) return volumes, err }
func getNetworkIDByName(c *check.C, name string) string { var ( v = url.Values{} filterArgs = filters.NewArgs() ) filterArgs.Add("name", name) filterJSON, err := filters.ToParam(filterArgs) c.Assert(err, checker.IsNil) v.Set("filters", filterJSON) status, body, err := sockRequest("GET", "/networks?"+v.Encode(), nil) c.Assert(status, checker.Equals, http.StatusOK) c.Assert(err, checker.IsNil) nJSON := []types.NetworkResource{} err = json.Unmarshal(body, &nJSON) c.Assert(err, checker.IsNil) c.Assert(len(nJSON), checker.Equals, 1) return nJSON[0].ID }
func (d *SwarmDaemon) checkRunningTaskImages(c *check.C) (interface{}, check.CommentInterface) { var tasks []swarm.Task filterArgs := filters.NewArgs() filterArgs.Add("desired-state", "running") filters, err := filters.ToParam(filterArgs) c.Assert(err, checker.IsNil) status, out, err := d.SockRequest("GET", "/tasks?filters="+filters, nil) c.Assert(status, checker.Equals, http.StatusOK, check.Commentf("output: %q", string(out))) c.Assert(err, checker.IsNil, check.Commentf(string(out))) c.Assert(json.Unmarshal(out, &tasks), checker.IsNil) result := make(map[string]int) for _, task := range tasks { if task.Status.State == swarm.TaskStateRunning { result[task.Spec.ContainerSpec.Image]++ } } return result, nil }
// TaskList returns the list of tasks. func (cli *Client) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) { query := url.Values{} if options.Filter.Len() > 0 { filterJSON, err := filters.ToParam(options.Filter) if err != nil { return nil, err } query.Set("filters", filterJSON) } resp, err := cli.get(ctx, "/tasks", query, nil) if err != nil { return nil, err } var tasks []swarm.Task err = json.NewDecoder(resp.body).Decode(&tasks) ensureReaderClosed(resp) return tasks, err }
func (b *Box) watchEvents() { const dieEvent = "die" since := time.Now() sleep := time.Second maxSleep := time.Second * 32 filterArgs := filters.NewArgs() filterArgs.Add("event", dieEvent) filterArgs.Add("label", isolateDockerLabel) fltrs, _ := filters.ToParam(filterArgs) var eventResponse struct { Status string `json:"status"` ID string `json:"id"` Time int64 `json:"time"` } logger := apexctx.GetLogger(b.ctx) for { eventsOptions := types.EventsOptions{ Since: strconv.FormatInt(since.Unix(), 10), Filters: filterArgs, } logger.Infof("listening Docker events since %s with filters %s", eventsOptions.Since, fltrs) resp, err := b.client.Events(b.ctx, eventsOptions) switch err { case nil: sleep = time.Second decoder := json.NewDecoder(resp) for { if err = decoder.Decode(&eventResponse); err != nil { logger.WithError(err).Error("unable to decode Docker events") resp.Close() break } // Save timestamp of the latest received event since = time.Unix(eventResponse.Time, 0) switch eventResponse.Status { case dieEvent: logger.WithField("id", eventResponse.ID).Info("container has died") var p *process b.muContainers.Lock() p, ok := b.containers[eventResponse.ID] delete(b.containers, eventResponse.ID) b.muContainers.Unlock() if ok { p.remove() } else { // NOTE: it could be orphaned worker from our previous launch logger.WithField("id", eventResponse.ID).Warn("unknown container will be removed") containerRemove(b.client, b.ctx, eventResponse.ID) } default: logger.WithField("status", eventResponse.Status).Warn("unknown status") } } case context.Canceled, context.DeadlineExceeded: logger.Info("event listenening has been cancelled") return default: // backoff sleep *= 2 if sleep > maxSleep { sleep = maxSleep } logger.WithError(err).Warnf("unable to listen events. Sleep %s", sleep) time.Sleep(sleep) } } }