container_registry.go

Documentation: github.com/xanzy/go-gitlab

     1  //
     2  // Copyright 2021, Sander van Harmelen
     3  //
     4  // Licensed under the Apache License, Version 2.0 (the "License");
     5  // you may not use this file except in compliance with the License.
     6  // You may obtain a copy of the License at
     7  //
     8  //     http://www.apache.org/licenses/LICENSE-2.0
     9  //
    10  // Unless required by applicable law or agreed to in writing, software
    11  // distributed under the License is distributed on an "AS IS" BASIS,
    12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  // See the License for the specific language governing permissions and
    14  // limitations under the License.
    15  //
    16  
    17  package gitlab
    18  
    19  import (
    20  	"fmt"
    21  	"net/http"
    22  	"time"
    23  )
    24  
    25  // ContainerRegistryService handles communication with the container registry
    26  // related methods of the GitLab API.
    27  //
    28  // GitLab API docs: https://docs.gitlab.com/ee/api/container_registry.html
    29  type ContainerRegistryService struct {
    30  	client *Client
    31  }
    32  
    33  // RegistryRepository represents a GitLab content registry repository.
    34  //
    35  // GitLab API docs: https://docs.gitlab.com/ee/api/container_registry.html
    36  type RegistryRepository struct {
    37  	ID                     int                      `json:"id"`
    38  	Name                   string                   `json:"name"`
    39  	Path                   string                   `json:"path"`
    40  	ProjectID              int                      `json:"project_id"`
    41  	Location               string                   `json:"location"`
    42  	CreatedAt              *time.Time               `json:"created_at"`
    43  	CleanupPolicyStartedAt *time.Time               `json:"cleanup_policy_started_at"`
    44  	TagsCount              int                      `json:"tags_count"`
    45  	Tags                   []*RegistryRepositoryTag `json:"tags"`
    46  }
    47  
    48  func (s RegistryRepository) String() string {
    49  	return Stringify(s)
    50  }
    51  
    52  // RegistryRepositoryTag represents a GitLab registry image tag.
    53  //
    54  // GitLab API docs: https://docs.gitlab.com/ee/api/container_registry.html
    55  type RegistryRepositoryTag struct {
    56  	Name          string     `json:"name"`
    57  	Path          string     `json:"path"`
    58  	Location      string     `json:"location"`
    59  	Revision      string     `json:"revision"`
    60  	ShortRevision string     `json:"short_revision"`
    61  	Digest        string     `json:"digest"`
    62  	CreatedAt     *time.Time `json:"created_at"`
    63  	TotalSize     int        `json:"total_size"`
    64  }
    65  
    66  func (s RegistryRepositoryTag) String() string {
    67  	return Stringify(s)
    68  }
    69  
    70  // ListRegistryRepositoriesOptions represents the available
    71  // ListRegistryRepositories() options.
    72  //
    73  // GitLab API docs:
    74  // https://docs.gitlab.com/ee/api/container_registry.html#list-registry-repositories
    75  type ListRegistryRepositoriesOptions struct {
    76  	ListOptions
    77  
    78  	// Deprecated: These options are deprecated for ListGroupRegistryRepositories calls. (Removed in GitLab 15.0)
    79  	Tags      *bool `url:"tags,omitempty" json:"tags,omitempty"`
    80  	TagsCount *bool `url:"tags_count,omitempty" json:"tags_count,omitempty"`
    81  }
    82  
    83  // ListProjectRegistryRepositories gets a list of registry repositories in a project.
    84  //
    85  // GitLab API docs:
    86  // https://docs.gitlab.com/ee/api/container_registry.html#within-a-project
    87  func (s *ContainerRegistryService) ListProjectRegistryRepositories(pid interface{}, opt *ListRegistryRepositoriesOptions, options ...RequestOptionFunc) ([]*RegistryRepository, *Response, error) {
    88  	project, err := parseID(pid)
    89  	if err != nil {
    90  		return nil, nil, err
    91  	}
    92  	u := fmt.Sprintf("projects/%s/registry/repositories", PathEscape(project))
    93  
    94  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
    95  	if err != nil {
    96  		return nil, nil, err
    97  	}
    98  
    99  	var repos []*RegistryRepository
   100  	resp, err := s.client.Do(req, &repos)
   101  	if err != nil {
   102  		return nil, resp, err
   103  	}
   104  
   105  	return repos, resp, nil
   106  }
   107  
   108  // ListGroupRegistryRepositories gets a list of registry repositories in a group.
   109  //
   110  // GitLab API docs:
   111  // https://docs.gitlab.com/ee/api/container_registry.html#within-a-group
   112  func (s *ContainerRegistryService) ListGroupRegistryRepositories(gid interface{}, opt *ListRegistryRepositoriesOptions, options ...RequestOptionFunc) ([]*RegistryRepository, *Response, error) {
   113  	group, err := parseID(gid)
   114  	if err != nil {
   115  		return nil, nil, err
   116  	}
   117  	u := fmt.Sprintf("groups/%s/registry/repositories", PathEscape(group))
   118  
   119  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
   120  	if err != nil {
   121  		return nil, nil, err
   122  	}
   123  
   124  	var repos []*RegistryRepository
   125  	resp, err := s.client.Do(req, &repos)
   126  	if err != nil {
   127  		return nil, resp, err
   128  	}
   129  
   130  	return repos, resp, nil
   131  }
   132  
   133  // GetSingleRegistryRepositoryOptions represents the available
   134  // GetSingleRegistryRepository() options.
   135  //
   136  // GitLab API docs:
   137  // https://docs.gitlab.com/ee/api/container_registry.html#get-details-of-a-single-repository
   138  type GetSingleRegistryRepositoryOptions struct {
   139  	Tags      *bool `url:"tags,omitempty" json:"tags,omitempty"`
   140  	TagsCount *bool `url:"tags_count,omitempty" json:"tags_count,omitempty"`
   141  }
   142  
   143  // GetSingleRegistryRepository gets the details of single registry repository.
   144  //
   145  // GitLab API docs:
   146  // https://docs.gitlab.com/ee/api/container_registry.html#get-details-of-a-single-repository
   147  func (s *ContainerRegistryService) GetSingleRegistryRepository(pid interface{}, opt *GetSingleRegistryRepositoryOptions, options ...RequestOptionFunc) (*RegistryRepository, *Response, error) {
   148  	project, err := parseID(pid)
   149  	if err != nil {
   150  		return nil, nil, err
   151  	}
   152  	u := fmt.Sprintf("registry/repositories/%s", PathEscape(project))
   153  
   154  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
   155  	if err != nil {
   156  		return nil, nil, err
   157  	}
   158  
   159  	repo := new(RegistryRepository)
   160  	resp, err := s.client.Do(req, repo)
   161  	if err != nil {
   162  		return nil, resp, err
   163  	}
   164  
   165  	return repo, resp, nil
   166  }
   167  
   168  // DeleteRegistryRepository deletes a repository in a registry.
   169  //
   170  // GitLab API docs:
   171  // https://docs.gitlab.com/ee/api/container_registry.html#delete-registry-repository
   172  func (s *ContainerRegistryService) DeleteRegistryRepository(pid interface{}, repository int, options ...RequestOptionFunc) (*Response, error) {
   173  	project, err := parseID(pid)
   174  	if err != nil {
   175  		return nil, err
   176  	}
   177  	u := fmt.Sprintf("projects/%s/registry/repositories/%d", PathEscape(project), repository)
   178  
   179  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   180  	if err != nil {
   181  		return nil, err
   182  	}
   183  
   184  	return s.client.Do(req, nil)
   185  }
   186  
   187  // ListRegistryRepositoryTagsOptions represents the available
   188  // ListRegistryRepositoryTags() options.
   189  //
   190  // GitLab API docs:
   191  // https://docs.gitlab.com/ee/api/container_registry.html#list-registry-repository-tags
   192  type ListRegistryRepositoryTagsOptions ListOptions
   193  
   194  // ListRegistryRepositoryTags gets a list of tags for given registry repository.
   195  //
   196  // GitLab API docs:
   197  // https://docs.gitlab.com/ee/api/container_registry.html#list-registry-repository-tags
   198  func (s *ContainerRegistryService) ListRegistryRepositoryTags(pid interface{}, repository int, opt *ListRegistryRepositoryTagsOptions, options ...RequestOptionFunc) ([]*RegistryRepositoryTag, *Response, error) {
   199  	project, err := parseID(pid)
   200  	if err != nil {
   201  		return nil, nil, err
   202  	}
   203  	u := fmt.Sprintf("projects/%s/registry/repositories/%d/tags",
   204  		PathEscape(project),
   205  		repository,
   206  	)
   207  
   208  	req, err := s.client.NewRequest(http.MethodGet, u, opt, options)
   209  	if err != nil {
   210  		return nil, nil, err
   211  	}
   212  
   213  	var tags []*RegistryRepositoryTag
   214  	resp, err := s.client.Do(req, &tags)
   215  	if err != nil {
   216  		return nil, resp, err
   217  	}
   218  
   219  	return tags, resp, nil
   220  }
   221  
   222  // GetRegistryRepositoryTagDetail get details of a registry repository tag
   223  //
   224  // GitLab API docs:
   225  // https://docs.gitlab.com/ee/api/container_registry.html#get-details-of-a-registry-repository-tag
   226  func (s *ContainerRegistryService) GetRegistryRepositoryTagDetail(pid interface{}, repository int, tagName string, options ...RequestOptionFunc) (*RegistryRepositoryTag, *Response, error) {
   227  	project, err := parseID(pid)
   228  	if err != nil {
   229  		return nil, nil, err
   230  	}
   231  	u := fmt.Sprintf("projects/%s/registry/repositories/%d/tags/%s",
   232  		PathEscape(project),
   233  		repository,
   234  		tagName,
   235  	)
   236  
   237  	req, err := s.client.NewRequest(http.MethodGet, u, nil, options)
   238  	if err != nil {
   239  		return nil, nil, err
   240  	}
   241  
   242  	tag := new(RegistryRepositoryTag)
   243  	resp, err := s.client.Do(req, &tag)
   244  	if err != nil {
   245  		return nil, resp, err
   246  	}
   247  
   248  	return tag, resp, nil
   249  }
   250  
   251  // DeleteRegistryRepositoryTag deletes a registry repository tag.
   252  //
   253  // GitLab API docs:
   254  // https://docs.gitlab.com/ee/api/container_registry.html#delete-a-registry-repository-tag
   255  func (s *ContainerRegistryService) DeleteRegistryRepositoryTag(pid interface{}, repository int, tagName string, options ...RequestOptionFunc) (*Response, error) {
   256  	project, err := parseID(pid)
   257  	if err != nil {
   258  		return nil, err
   259  	}
   260  	u := fmt.Sprintf("projects/%s/registry/repositories/%d/tags/%s",
   261  		PathEscape(project),
   262  		repository,
   263  		tagName,
   264  	)
   265  
   266  	req, err := s.client.NewRequest(http.MethodDelete, u, nil, options)
   267  	if err != nil {
   268  		return nil, err
   269  	}
   270  
   271  	return s.client.Do(req, nil)
   272  }
   273  
   274  // DeleteRegistryRepositoryTagsOptions represents the available
   275  // DeleteRegistryRepositoryTags() options.
   276  //
   277  // GitLab API docs:
   278  // https://docs.gitlab.com/ee/api/container_registry.html#delete-registry-repository-tags-in-bulk
   279  type DeleteRegistryRepositoryTagsOptions struct {
   280  	NameRegexpDelete *string `url:"name_regex_delete,omitempty" json:"name_regex_delete,omitempty"`
   281  	NameRegexpKeep   *string `url:"name_regex_keep,omitempty" json:"name_regex_keep,omitempty"`
   282  	KeepN            *int    `url:"keep_n,omitempty" json:"keep_n,omitempty"`
   283  	OlderThan        *string `url:"older_than,omitempty" json:"older_than,omitempty"`
   284  
   285  	// Deprecated: NameRegexp is deprecated in favor of NameRegexpDelete.
   286  	NameRegexp *string `url:"name_regex,omitempty" json:"name_regex,omitempty"`
   287  }
   288  
   289  // DeleteRegistryRepositoryTags deletes repository tags in bulk based on
   290  // given criteria.
   291  //
   292  // GitLab API docs:
   293  // https://docs.gitlab.com/ee/api/container_registry.html#delete-registry-repository-tags-in-bulk
   294  func (s *ContainerRegistryService) DeleteRegistryRepositoryTags(pid interface{}, repository int, opt *DeleteRegistryRepositoryTagsOptions, options ...RequestOptionFunc) (*Response, error) {
   295  	project, err := parseID(pid)
   296  	if err != nil {
   297  		return nil, err
   298  	}
   299  	u := fmt.Sprintf("projects/%s/registry/repositories/%d/tags",
   300  		PathEscape(project),
   301  		repository,
   302  	)
   303  
   304  	req, err := s.client.NewRequest(http.MethodDelete, u, opt, options)
   305  	if err != nil {
   306  		return nil, err
   307  	}
   308  
   309  	return s.client.Do(req, nil)
   310  }
   311
View as plain text