view release on metacpan or  search on metacpan

lib/PAX/StandaloneRuntime.pm  view on Meta::CPAN

            my %known = map { $_ => 1 } _code_for($discover_names_method)->($self, project_root => $project_root, service_map => $service_map);
            my @services;
            my %seen;
            for my $arg (@{$argv}) {
                next if !defined $arg || $arg eq '';
                next if $arg =~ /^-/;
                next if !$known{$arg};
                next if $seen{$arg}++;
                push @services, $arg;
            }
            return @services;
        };
        return _install_sub_impl($package, $name, $sub->{prototype}, $impl);
    }

    if (($sub->{op} // '') eq 'docker_compose_discover_service_files') {
        my $service_disabled_method = $sub->{service_disabled_method} // die 'compiled sub service-disabled method missing';
        my $lookup_roots_method = $sub->{lookup_roots_method} // die 'compiled sub lookup-roots method missing';
        $impl = sub {
            my ($self, %args) = @_;
            my $service = $args{service} || return;
            my $project_root = $args{project_root} || Cwd::cwd();
            return if _code_for($service_disabled_method)->($self, project_root => $project_root, service => $service);
            my @roots = _code_for($lookup_roots_method)->($self, project_root => $project_root, service => $service);
            my @files;
            my %seen;
            for my $root (@roots) {
                next if !defined $root || $root eq '';
                my $service_root = File::Spec->catdir($root, $service);
                next if !-d $service_root;
                my $development = File::Spec->catfile($service_root, 'development.compose.yml');
                if (-f $development) {
                    push @files, $development if !$seen{$development}++;
                    next;
                }
                my $compose = File::Spec->catfile($service_root, 'compose.yml');
                push @files, $compose if -f $compose && !$seen{$compose}++;
            }
            return @files;
        };
        return _install_sub_impl($package, $name, $sub->{prototype}, $impl);
    }

    if (($sub->{op} // '') eq 'docker_compose_resolve') {
        my $base_files_method = $sub->{base_files_method} // die 'compiled sub base-files method missing';
        my $infer_services_method = $sub->{infer_services_method} // die 'compiled sub infer-services method missing';
        my $discover_enabled_method = $sub->{discover_enabled_method} // die 'compiled sub discover-enabled method missing';
        my $discover_service_files_method = $sub->{discover_service_files_method} // die 'compiled sub discover-service-files method missing';
        my $expand_path_method = $sub->{expand_path_method} // die 'compiled sub expand-path method missing';
        my $config_root_method = $sub->{config_root_method} // die 'compiled sub config-root method missing';
        $impl = sub {
            my ($self, %args) = @_;
            my $project_root = $args{project_root} || $self->{paths}->current_project_root || Cwd::cwd();
            my $docker_cfg = $self->{config}->docker_config;
            my $docker_root = _code_for($config_root_method)->($self);
            my @passthrough = @{ $args{args} || [] };
            my (@compose_files, @layers);
            my @base = _code_for($base_files_method)->($self, $project_root);
            push @compose_files, @base;
            push @layers, { name => 'base', files => [@base] };
            my @project_overlays = (@{ $docker_cfg->{files} || [] }, @{ $docker_cfg->{project_overlays} || [] });
            push @compose_files, @project_overlays;
            push @layers, { name => 'project', files => [@project_overlays] } if @project_overlays;
            my @addons = @{ $args{addons} || [] };
            my @modes = @{ $args{modes} || [] };
            my @services = @{ $args{services} || [] };
            my %addon_map = %{ $docker_cfg->{addons} || {} };
            my %mode_map = %{ $docker_cfg->{modes} || {} };
            my %service_map = %{ $docker_cfg->{services} || {} };
            my @inferred_services = _code_for($infer_services_method)->($self, args => \@passthrough, project_root => $project_root, service_map => \%service_map);
            my %service_seen;
            @services = grep { !$service_seen{$_}++ } (@services, @inferred_services);
            if (!@services) {
                my @auto_services = _code_for($discover_enabled_method)->($self, project_root => $project_root, service_map => \%service_map);
                @services = grep { !$service_seen{$_}++ } @auto_services;
            }
            my @service_files;
            for my $service (@services) {
                my $def = $service_map{$service};
                next if ref($def) ne 'HASH';
                push @service_files, @{ $def->{files} || [] } if ref($def->{files}) eq 'ARRAY';
            }
            for my $service (@services) {
                push @service_files, _code_for($discover_service_files_method)->($self, service => $service, project_root => $project_root, modes => \@modes);
            }
            push @compose_files, @service_files;
            push @layers, { name => 'service', files => [@service_files] } if @service_files;
            my @addon_files;
            for my $addon (@addons) {
                my $def = $addon_map{$addon};
                next if ref($def) ne 'HASH';
                push @addon_files, @{ $def->{files} || [] } if ref($def->{files}) eq 'ARRAY';
                push @modes, @{ $def->{modes} || [] } if ref($def->{modes}) eq 'ARRAY';
            }
            push @compose_files, @addon_files;
            push @layers, { name => 'addon', files => [@addon_files] } if @addon_files;
            my @mode_files;
            for my $mode (@modes) {
                my $def = $mode_map{$mode};
                next if ref($def) ne 'HASH';
                push @mode_files, @{ $def->{files} || [] } if ref($def->{files}) eq 'ARRAY';
            }
            push @compose_files, @mode_files;
            push @layers, { name => 'mode', files => [@mode_files] } if @mode_files;
            my (@files, %seen);
            for my $file (@compose_files) {
                next if !defined $file || $file eq '';
                $file = _code_for($expand_path_method)->($self, $file);
                $file = File::Spec->catfile($project_root, $file) if !File::Spec->file_name_is_absolute($file);
                next if $seen{$file}++;
                push @files, $file if -f $file;
            }
            my %env = (%{ $docker_cfg->{env} || {} }, DDDC => $docker_root);
            for my $addon (@addons) {
                my $def = $addon_map{$addon};
                next if ref($def) ne 'HASH' || ref($def->{env}) ne 'HASH';
                @env{keys %{$def->{env}}} = values %{$def->{env}};
            }
            for my $mode (@modes) {
                my $def = $mode_map{$mode};
                next if ref($def) ne 'HASH' || ref($def->{env}) ne 'HASH';
                @env{keys %{$def->{env}}} = values %{$def->{env}};
            }