//GetImageRevision get the image revision func (imageCreator LocalImageCreator) GetImageRevision(dockerInfo *DockerInfo) (*types.Image, error) { filters := filters.NewArgs() //append filters as required based on the input repoFilter := TAG_REPO + "=" + dockerInfo.RepoName filters.Add("label", repoFilter) applicationFilter := TAG_APPLICATION + "=" + dockerInfo.ImageName filters.Add("label", applicationFilter) revisionFilter := TAG_REVISION + "=" + dockerInfo.Revision filters.Add("label", revisionFilter) opts := types.ImageListOptions{All: false, Filters: filters} images, err := imageCreator.client.ImageList(context.Background(), opts) if err == nil && len(images) > 0 { return &images[0], err } return nil, err }
// enumberates volumes and builds refCountsMap, then sync with mount info func (r refCountsMap) discoverAndSync(c *client.Client, d *vmdkDriver) error { // we assume to have empty refcounts. Let's enforce for name := range r { delete(r, name) } filters := filters.NewArgs() filters.Add("status", "running") filters.Add("status", "paused") filters.Add("status", "restarting") containers, err := c.ContainerList(context.Background(), types.ContainerListOptions{ All: true, Filter: filters, }) if err != nil { return err } log.Debugf("Found %d running or paused containers", len(containers)) for _, ct := range containers { containerJSONInfo, err := c.ContainerInspect(context.Background(), ct.ID) if err != nil { log.Errorf("ContainerInspect failed for %s (err: %v)", ct.Names, err) continue } log.Debugf(" Mounts for %v", ct.Names) for _, mount := range containerJSONInfo.Mounts { if mount.Driver == driverName { r.incr(mount.Name) log.Debugf(" name=%v (driver=%s source=%s)", mount.Name, mount.Driver, mount.Source) } } } // Check that refcounts and actual mount info from Linux match // If they don't, unmount unneeded stuff, or yell if something is // not mounted but should be (it's error. we should not get there) r.getMountInfo() r.syncMountsWithRefCounters(d) return nil }
//GetImages get all the images for the specified repository and application func (imageCreator LocalImageCreator) GetImages(repository string, application string) (*[]types.Image, error) { filters := filters.NewArgs() //append filters as required based on the input repoFilter := TAG_REPO + "=" + repository filters.Add("label", repoFilter) applicationFilter := TAG_APPLICATION + "=" + application filters.Add("label", applicationFilter) opts := types.ImageListOptions{All: false, Filters: filters} images, err := imageCreator.client.ImageList(context.Background(), opts) return &images, err }
//createFilter generate filter from search func createFilter(search *DockerInfo) *filters.Args { filters := filters.NewArgs() //append filters as required based on the input if search.RepoName != "" { newFilter := TAG_REPO + "=" + search.RepoName filters.Add("label", newFilter) } if search.ImageName != "" { newFilter := TAG_APPLICATION + "=" + search.ImageName filters.Add("label", newFilter) } if search.Revision != "" { newFilter := TAG_REVISION + "=" + search.Revision filters.Add("label", newFilter) } return &filters }
// List lists the containers managed by kermit func (p *Project) List() ([]types.Container, error) { filters := filters.NewArgs() for key, value := range p.Labels { filters.Add("label", fmt.Sprintf("%s=%s", key, value)) } containers, err := p.Client.ContainerList(context.Background(), types.ContainerListOptions{ Filter: filters, }) if err != nil { return nil, err } return containers, nil }
func (c *Cluster) listContainerForNode(nodeID string) ([]string, error) { var ids []string filters := filters.NewArgs() filters.Add("label", fmt.Sprintf("com.docker.swarm.node.id=%s", nodeID)) containers, err := c.config.Backend.Containers(&apitypes.ContainerListOptions{ Filter: filters, }) if err != nil { return []string{}, err } for _, c := range containers { ids = append(ids, c.ID) } return ids, nil }
//GetApplications get all remote application for the specified repository func (imageCreator LocalImageCreator) GetApplications(repository string) (*[]string, error) { filters := filters.NewArgs() //append filters as required based on the input newFilter := TAG_REPO + "=" + repository filters.Add("label", newFilter) opts := types.ImageListOptions{All: false, Filters: filters} images, err := imageCreator.client.ImageList(context.Background(), opts) if err != nil { return nil, err } return getTags(&images, TAG_APPLICATION), nil }
func TestImageList(t *testing.T) { expectedURL := "/images/json" noDanglingfilters := filters.NewArgs() noDanglingfilters.Add("dangling", "false") filters := filters.NewArgs() filters.Add("label", "label1") filters.Add("label", "label2") filters.Add("dangling", "true") listCases := []struct { options types.ImageListOptions expectedQueryParams map[string]string }{ { options: types.ImageListOptions{}, expectedQueryParams: map[string]string{ "all": "", "filter": "", "filters": "", }, }, { options: types.ImageListOptions{ All: true, MatchName: "image_name", }, expectedQueryParams: map[string]string{ "all": "1", "filter": "image_name", "filters": "", }, }, { options: types.ImageListOptions{ Filters: filters, }, expectedQueryParams: map[string]string{ "all": "", "filter": "", "filters": `{"dangling":{"true":true},"label":{"label1":true,"label2":true}}`, }, }, { options: types.ImageListOptions{ Filters: noDanglingfilters, }, expectedQueryParams: map[string]string{ "all": "", "filter": "", "filters": `{"dangling":{"false":true}}`, }, }, } for _, listCase := range listCases { client := &Client{ transport: transport.NewMockClient(nil, func(req *http.Request) (*http.Response, error) { if !strings.HasPrefix(req.URL.Path, expectedURL) { return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL) } query := req.URL.Query() for key, expected := range listCase.expectedQueryParams { actual := query.Get(key) if actual != expected { return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual) } } content, err := json.Marshal([]types.Image{ { ID: "image_id2", }, { ID: "image_id2", }, }) if err != nil { return nil, err } return &http.Response{ StatusCode: http.StatusOK, Body: ioutil.NopCloser(bytes.NewReader(content)), }, nil }), } images, err := client.ImageList(listCase.options) if err != nil { t.Fatal(err) } if len(images) != 2 { t.Fatalf("expected 2 images, got %v", images) } } }
func TestTaskList(t *testing.T) { expectedURL := "/tasks" filters := filters.NewArgs() filters.Add("label", "label1") filters.Add("label", "label2") listCases := []struct { options types.TaskListOptions expectedQueryParams map[string]string }{ { options: types.TaskListOptions{}, expectedQueryParams: map[string]string{ "filters": "", }, }, { options: types.TaskListOptions{ Filter: filters, }, expectedQueryParams: map[string]string{ "filters": `{"label":{"label1":true,"label2":true}}`, }, }, } for _, listCase := range listCases { client := &Client{ transport: newMockClient(nil, func(req *http.Request) (*http.Response, error) { if !strings.HasPrefix(req.URL.Path, expectedURL) { return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL) } query := req.URL.Query() for key, expected := range listCase.expectedQueryParams { actual := query.Get(key) if actual != expected { return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual) } } content, err := json.Marshal([]swarm.Task{ { ID: "task_id1", }, { ID: "task_id2", }, }) if err != nil { return nil, err } return &http.Response{ StatusCode: http.StatusOK, Body: ioutil.NopCloser(bytes.NewReader(content)), }, nil }), } tasks, err := client.TaskList(context.Background(), listCase.options) if err != nil { t.Fatal(err) } if len(tasks) != 2 { t.Fatalf("expected 2 tasks, got %v", tasks) } } }
func TestContainerList(t *testing.T) { expectedURL := "/containers/json" expectedFilters := `{"before":{"container":true},"label":{"label1":true,"label2":true}}` client := &Client{ transport: newMockClient(nil, func(req *http.Request) (*http.Response, error) { if !strings.HasPrefix(req.URL.Path, expectedURL) { return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL) } query := req.URL.Query() all := query.Get("all") if all != "1" { return nil, fmt.Errorf("all not set in URL query properly. Expected '1', got %s", all) } limit := query.Get("limit") if limit != "0" { return nil, fmt.Errorf("limit should have not be present in query. Expected '0', got %s", limit) } since := query.Get("since") if since != "container" { return nil, fmt.Errorf("since not set in URL query properly. Expected 'container', got %s", since) } before := query.Get("before") if before != "" { return nil, fmt.Errorf("before should have not be present in query, go %s", before) } size := query.Get("size") if size != "1" { return nil, fmt.Errorf("size not set in URL query properly. Expected '1', got %s", size) } filters := query.Get("filters") if filters != expectedFilters { return nil, fmt.Errorf("expected filters incoherent '%v' with actual filters %v", expectedFilters, filters) } b, err := json.Marshal([]types.Container{ { ID: "container_id1", }, { ID: "container_id2", }, }) if err != nil { return nil, err } return &http.Response{ StatusCode: http.StatusOK, Body: ioutil.NopCloser(bytes.NewReader(b)), }, nil }), } filters := filters.NewArgs() filters.Add("label", "label1") filters.Add("label", "label2") filters.Add("before", "container") containers, err := client.ContainerList(context.Background(), types.ContainerListOptions{ Size: true, All: true, Since: "container", Filter: filters, }) if err != nil { t.Fatal(err) } if len(containers) != 2 { t.Fatalf("expected 2 containers, got %v", containers) } }
func TestEvents(t *testing.T) { expectedURL := "/events" filters := filters.NewArgs() filters.Add("label", "label1") filters.Add("label", "label2") expectedFiltersJSON := `{"label":{"label1":true,"label2":true}}` eventsCases := []struct { options types.EventsOptions expectedQueryParams map[string]string }{ { options: types.EventsOptions{ Since: "invalid but valid", }, expectedQueryParams: map[string]string{ "since": "invalid but valid", }, }, { options: types.EventsOptions{ Until: "invalid but valid", }, expectedQueryParams: map[string]string{ "until": "invalid but valid", }, }, { options: types.EventsOptions{ Filters: filters, }, expectedQueryParams: map[string]string{ "filters": expectedFiltersJSON, }, }, } for _, eventsCase := range eventsCases { client := &Client{ transport: newMockClient(nil, func(req *http.Request) (*http.Response, error) { if !strings.HasPrefix(req.URL.Path, expectedURL) { return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL) } query := req.URL.Query() for key, expected := range eventsCase.expectedQueryParams { actual := query.Get(key) if actual != expected { return nil, fmt.Errorf("%s not set in URL query properly. Expected '%s', got %s", key, expected, actual) } } return &http.Response{ StatusCode: http.StatusOK, Body: ioutil.NopCloser(bytes.NewReader([]byte("response"))), }, nil }), } body, err := client.Events(context.Background(), eventsCase.options) if err != nil { t.Fatal(err) } defer body.Close() content, err := ioutil.ReadAll(body) if err != nil { t.Fatal(err) } if string(content) != "response" { t.Fatalf("expected response to contain 'response', got %s", string(content)) } } }