view release on metacpan or  search on metacpan

lib/Dist/Zilla/Plugin/Docker/API/Client.pm  view on Meta::CPAN

    for my $entry ($dir->children) {
        if ($entry->is_dir) {
            push @files, $self->_collect_files($root, $entry);
        }
        else {
            push @files, $entry;
        }
    }
    return @files;
}

sub _push_tags {
    my ($self, $docker, $tags, $result_ref) = @_;

    for my $tag (@$tags) {
        $self->logger->("Pushing $tag...");

        my $push_progress = sub {
            my ($event) = @_;
            if ($event->{errorDetail}) {
                $self->logger_fatal->("Push error for $tag: " . $event->{errorDetail}{message});
            }
            elsif ($event->{progress}) {
                $self->logger->($event->{status} . ' ' . $event->{progress});
            }
        };

        my $auth = $self->auth_for_image_ref($tag);

        eval {
            my $events = $docker->images->push($tag, auth => $auth);
            for my $event (@{$events // []}) {
                $push_progress->($event);
                if ($event->{aux} && $event->{aux}{Digest}) {
                    $$result_ref->{digest} = $event->{aux}{Digest};
                }
            }
        };

        if ($@) {
            $self->logger->("Warning: failed to push $tag: $@");
        }
        else {
            push @{ $$result_ref->{pushed} }, $tag;
        }
    }
}

sub auth_for_image_ref {
    my ($self, $image_ref) = @_;
    my $registry = $self->_registry_for_image_ref($image_ref);
    return $self->_auth_for_registry($registry);
}

sub _registry_for_image_ref {
    my ($self, $image_ref) = @_;

    # Strip ":tag" or "@sha256:..." suffix from the image part.
    my $name = $image_ref;
    $name =~ s/\@sha256:.*$//;
    my @parts = split m{/}, $name;

    # If the first component does NOT look like a registry host
    # (no dot, no colon, not "localhost"), it's an implicit Docker Hub repo.
    if (@parts < 2 || ($parts[0] !~ /[.:]/ && $parts[0] ne 'localhost')) {
        return 'https://index.docker.io/v1/';
    }
    return $parts[0];
}

sub _auth_for_registry {
    my ($self, $registry) = @_;

    my $config = $self->_docker_config;
    my $auths = $config->{auths} // {};

    my @candidates = ($registry);
    if ($registry eq 'https://index.docker.io/v1/'
        || $registry eq 'index.docker.io'
        || $registry eq 'docker.io') {
        push @candidates,
            'https://index.docker.io/v1/',
            'https://index.docker.io/v2/',
            'index.docker.io',
            'docker.io';
    }

    my $entry;
    for my $key (@candidates) {
        if (exists $auths->{$key}) {
            $entry = $auths->{$key};
            last;
        }
    }
    return undef unless $entry;

    my %auth = (serveraddress => $registry);

    if ($entry->{identitytoken}) {
        $auth{identitytoken} = $entry->{identitytoken};
        return \%auth;
    }

    if ($entry->{auth}) {
        my $decoded = eval { decode_base64($entry->{auth}) };
        if (defined $decoded && $decoded =~ /^([^:]+):(.*)$/s) {
            $auth{username} = $1;
            $auth{password} = $2;
            return \%auth;
        }
    }

    if (defined $entry->{username} || defined $entry->{password}) {
        $auth{username} = $entry->{username} if defined $entry->{username};
        $auth{password} = $entry->{password} if defined $entry->{password};
        return \%auth;
    }

    return undef;
}