本文整理汇总了Golang中github.com/docker/distribution/reference.Parse函数的典型用法代码示例。如果您正苦于以下问题:Golang Parse函数的具体用法?Golang Parse怎么用?Golang Parse使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Parse函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: Set
func (m customImageMap) Set(value string) error {
parts := strings.Split(value, ",")
if len(parts) != 2 {
return errors.New("invalid custome image format, expected \"name,reference\"")
}
ref, err := reference.Parse(parts[0])
if err != nil {
return err
}
namedTagged, ok := ref.(reference.NamedTagged)
if !ok {
return fmt.Errorf("reference %s must contain name and tag", ref.String())
}
source, err := reference.ParseNamed(parts[1])
if err != nil {
return err
}
m[parts[0]] = CustomImage{
Source: source.String(),
Target: namedTagged,
}
return nil
}
示例2: startTimer
func (ttles *TTLExpirationScheduler) startTimer(entry *schedulerEntry, ttl time.Duration) *time.Timer {
return time.AfterFunc(ttl, func() {
ttles.Lock()
defer ttles.Unlock()
var f expiryFunc
switch entry.EntryType {
case entryTypeBlob:
f = ttles.onBlobExpire
case entryTypeManifest:
f = ttles.onManifestExpire
default:
f = func(reference.Reference) error {
return fmt.Errorf("scheduler entry type")
}
}
ref, err := reference.Parse(entry.Key)
if err == nil {
if err := f(ref); err != nil {
context.GetLogger(ttles.ctx).Errorf("Scheduler error returned from OnExpire(%s): %s", entry.Key, err)
}
} else {
context.GetLogger(ttles.ctx).Errorf("Error unpacking reference: %s", err)
}
delete(ttles.entries, entry.Key)
ttles.indexDirty = true
})
}
示例3: matchImageIDOnly
// matchImageIDOnly checks that the given image specifier is a digest-only
// reference, and that it matches the given image.
func matchImageIDOnly(inspected dockertypes.ImageInspect, image string) bool {
// If the image ref is literally equal to the inspected image's ID,
// just return true here (this might be the case for Docker 1.9,
// where we won't have a digest for the ID)
if inspected.ID == image {
return true
}
// Otherwise, we should try actual parsing to be more correct
ref, err := dockerref.Parse(image)
if err != nil {
glog.V(4).Infof("couldn't parse image reference %q: %v", image, err)
return false
}
digest, isDigested := ref.(dockerref.Digested)
if !isDigested {
glog.V(4).Infof("the image reference %q was not a digest reference")
return false
}
id, err := dockerdigest.ParseDigest(inspected.ID)
if err != nil {
glog.V(4).Infof("couldn't parse image ID reference %q: %v", id, err)
return false
}
if digest.Digest().Algorithm().String() == id.Algorithm().String() && digest.Digest().Hex() == id.Hex() {
return true
}
glog.V(4).Infof("The reference %s does not directly refer to the given image's ID (%q)", image, inspected.ID)
return false
}
示例4: ensureImage
func ensureImage(cli DockerClient, image string) (string, error) {
ctx := context.Background()
info, _, err := cli.ImageInspectWithRaw(ctx, image, false)
if err == nil {
logrus.Debugf("Image found locally %s", image)
return info.ID, nil
}
if !client.IsErrImageNotFound(err) {
logrus.Errorf("Error inspecting image %q: %v", image, err)
return "", err
}
// Image must be tagged reference if it does not exist
ref, err := reference.Parse(image)
if err != nil {
logrus.Errorf("Image is not valid reference %q: %v", image, err)
return "", err
}
tagged, ok := ref.(reference.NamedTagged)
if !ok {
logrus.Errorf("Tagged reference required %q", image)
return "", errors.New("invalid reference, tag needed")
}
pullStart := time.Now()
pullOptions := types.ImagePullOptions{
PrivilegeFunc: registryAuthNotSupported,
}
resp, err := cli.ImagePull(ctx, tagged.String(), pullOptions)
if err != nil {
logrus.Errorf("Error pulling image %q: %v", tagged.String(), err)
return "", err
}
defer resp.Close()
outFd, isTerminalOut := term.GetFdInfo(os.Stdout)
if err = jsonmessage.DisplayJSONMessagesStream(resp, os.Stdout, outFd, isTerminalOut, nil); err != nil {
logrus.Errorf("Error copying pull output: %v", err)
return "", err
}
// TODO: Get pulled digest
logFields := logrus.Fields{
timerKey: time.Since(pullStart),
"image": tagged.String(),
}
logrus.WithFields(logFields).Info("image pulled")
info, _, err = cli.ImageInspectWithRaw(ctx, tagged.String(), false)
if err != nil {
return "", nil
}
return info.ID, nil
}
示例5: testRefs
func testRefs(t *testing.T) (reference.Reference, reference.Reference, reference.Reference) {
ref1, err := reference.Parse("[email protected]:aaaaeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
if err != nil {
t.Fatalf("could not parse reference: %v", err)
}
ref2, err := reference.Parse("[email protected]:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
if err != nil {
t.Fatalf("could not parse reference: %v", err)
}
ref3, err := reference.Parse("[email protected]:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc")
if err != nil {
t.Fatalf("could not parse reference: %v", err)
}
return ref1, ref2, ref3
}
示例6: ParseImageName
// parseImageName parses a docker image string into two parts: repo and tag.
// If tag is empty, return the defaultImageTag.
func ParseImageName(image string) (string, string) {
ref, _ := reference.Parse(image)
switch ref := ref.(type) {
default:
return ref.String(), defaultImageTag
case reference.NamedTagged:
return ref.Name(), ref.Tag()
case reference.Named:
return ref.Name(), defaultImageTag
}
}
示例7: getNamedTagged
func getNamedTagged(image string) (reference.NamedTagged, error) {
ref, err := reference.Parse(image)
if err != nil {
return nil, err
}
named, ok := ref.(reference.NamedTagged)
if !ok {
return nil, fmt.Errorf("Image reference must have name and tag: %s", image)
}
return named, nil
}
示例8: assertTagged
func assertTagged(image string) reference.NamedTagged {
ref, err := reference.Parse(image)
if err != nil {
logrus.Panicf("Invalid reference %q: %v", image, err)
}
named, ok := ref.(reference.NamedTagged)
if !ok {
logrus.Panicf("Image reference must have name and tag: %s", image)
}
return named
}
示例9: newSuiteConfiguration
func newSuiteConfiguration(path string, config suiteConfiguration) (*configurationSuite, error) {
customImages := make([]CustomImage, 0, len(config.CustomImages))
for _, value := range config.CustomImages {
ref, err := reference.Parse(value.Tag)
if err != nil {
return nil, err
}
target, ok := ref.(reference.NamedTagged)
if !ok {
return nil, fmt.Errorf("expecting name:tag for image target, got %s", value.Tag)
}
customImages = append(customImages, CustomImage{
Source: value.Default,
Target: target,
})
}
images := make([]reference.NamedTagged, 0, len(config.Images))
for _, image := range config.Images {
named, err := getNamedTagged(image)
if err != nil {
return nil, err
}
images = append(images, named)
}
var base reference.NamedTagged
if config.Base != "" {
var err error
base, err = getNamedTagged(config.Base)
if err != nil {
return nil, err
}
}
name := config.Name
if name == "" {
name = filepath.Base(path)
}
return &configurationSuite{
config: config,
path: path,
base: base,
customImages: customImages,
images: images,
resolvedName: name,
}, nil
}
示例10: populateTestStorage
func populateTestStorage(
t *testing.T,
driver driver.StorageDriver,
setManagedByOpenShift bool,
schemaVersion int,
repoImages map[string]int,
testImages map[string][]*imageapi.Image,
) (map[string][]*imageapi.Image, error) {
ctx := context.Background()
reg, err := storage.NewRegistry(ctx, driver)
if err != nil {
t.Fatalf("error creating registry: %v", err)
}
result := make(map[string][]*imageapi.Image)
for key, value := range testImages {
images := make([]*imageapi.Image, len(value))
copy(images, value)
result[key] = images
}
for imageReference := range repoImages {
parsed, err := reference.Parse(imageReference)
if err != nil {
t.Fatalf("failed to parse reference %q: %v", imageReference, err)
}
namedTagged, ok := parsed.(reference.NamedTagged)
if !ok {
t.Fatalf("expected NamedTagged reference, not %T", parsed)
}
imageCount := repoImages[imageReference]
for i := 0; i < imageCount; i++ {
img, err := storeTestImage(ctx, reg, namedTagged, schemaVersion, setManagedByOpenShift)
if err != nil {
t.Fatal(err)
}
arr := result[imageReference]
t.Logf("created image %[email protected]%s image with layers:", namedTagged.Name(), img.Name)
for _, l := range img.DockerImageLayers {
t.Logf(" %s of size %d", l.Name, l.LayerSize)
}
result[imageReference] = append(arr, img)
}
}
return result, nil
}
示例11: mustImage
func mustImage(source, target, version string) CustomImage {
ref, err := reference.Parse(target)
if err != nil {
panic(err)
}
namedTagged, ok := ref.(reference.NamedTagged)
if !ok {
panic("must provided named tagged for image target")
}
return CustomImage{
Source: source,
Target: namedTagged,
Version: version,
}
}
示例12: tagImage
func tagImage(ctx context.Context, cli DockerClient, img, tag string) error {
ref, err := reference.Parse(tag)
if err != nil {
return fmt.Errorf("invalid tag %s: %v", tag, err)
}
namedTagged, ok := ref.(reference.NamedTagged)
if !ok {
return fmt.Errorf("expecting named tagged reference: %s", tag)
}
tagOptions := types.ImageTagOptions{
Force: true,
}
if err := cli.ImageTag(ctx, img, namedTagged.String(), tagOptions); err != nil {
return fmt.Errorf("error tagging image %s as %s: %v", img, tag, err)
}
return nil
}
示例13: tagImage
func tagImage(client *dockerclient.Client, img, tag string) error {
ref, err := reference.Parse(tag)
if err != nil {
return fmt.Errorf("invalid tag %s: %v", tag, err)
}
namedTagged, ok := ref.(reference.NamedTagged)
if !ok {
return fmt.Errorf("expecting named tagged reference: %s", tag)
}
tagOptions := dockerclient.TagImageOptions{
Repo: namedTagged.Name(),
Tag: namedTagged.Tag(),
Force: true,
}
if err := client.TagImage(img, tagOptions); err != nil {
return fmt.Errorf("error tagging image %s as %s: %v", img, tag, err)
}
return nil
}
示例14: ensureImage
func ensureImage(client DockerClient, image string) (string, error) {
info, err := client.InspectImage(image)
if err == nil {
logrus.Debugf("Image found locally %s", image)
return info.ID, nil
}
if err != dockerclient.ErrNoSuchImage {
logrus.Errorf("Error inspecting image %q: %v", image, err)
return "", err
}
// Image must be tagged reference if it does not exist
ref, err := reference.Parse(image)
if err != nil {
logrus.Debugf("Image is not valid reference %q: %v", image, err)
}
tagged, ok := ref.(reference.NamedTagged)
if !ok {
logrus.Debugf("Tagged reference required %q", image)
return "", errors.New("invalid reference, tag needed")
}
logrus.Infof("Pulling image %s", tagged.String())
pullOptions := dockerclient.PullImageOptions{
Repository: tagged.Name(),
Tag: tagged.Tag(),
OutputStream: os.Stdout,
}
if err := client.PullImage(pullOptions, dockerclient.AuthConfiguration{}); err != nil {
logrus.Errorf("Error pulling image %q: %v", tagged.String(), err)
return "", err
}
// TODO: Get pulled digest and inspect by digest
info, err = client.InspectImage(tagged.String())
if err != nil {
return "", nil
}
return info.ID, nil
}
示例15: Set
func (m customImageMap) Set(value string) error {
parts := strings.Split(value, ",")
if len(parts) < 2 || len(parts) > 3 {
return errors.New("invalid custom image format, expected \"name,reference[,version]\"")
}
ref, err := reference.Parse(parts[0])
if err != nil {
return err
}
namedTagged, ok := ref.(reference.NamedTagged)
if !ok {
return fmt.Errorf("reference %s must contain name and tag", ref.String())
}
source, err := reference.ParseNamed(parts[1])
if err != nil {
return err
}
var version string
if len(parts) == 3 {
version = parts[2]
} else if refTag, ok := source.(reference.Tagged); ok {
version = refTag.Tag()
} else {
// TODO: In this case is it better to leave it blank and use the default
// from the configuration file?
version = namedTagged.Tag()
}
key := fmt.Sprintf("%s,%s", parts[0], parts[1])
m[key] = CustomImage{
Source: source.String(),
Target: namedTagged,
Version: version,
}
return nil
}