view release on metacpan or  search on metacpan

bin/sbozyp  view on Meta::CPAN

    }
    my @removable_deps; for my $pkgname (keys %deps) {
        if (my $dep = $deps{$pkgname}) {
            push @removable_deps, $dep;
        }
    }
    @removable_deps = pkgs_sorted(@removable_deps);
    return @removable_deps;
}

sub pkg_prepare_for_build {
    my ($pkg, $keep_src, $skip_md5) = @_;
    my $arch = arch();
    if (my $arch_problem = $pkg->{ARCH_UNSUPPORTED}) {
        sbozyp_die("$pkg->{PKGNAME} is $arch_problem on $arch");
    }
    my %url_md5;
    if ($arch eq 'x86_64' and my @urls = @{$pkg->{DOWNLOAD_x86_64}}) {
        @url_md5{@urls} = @{$pkg->{MD5SUM_x86_64}};
    } else {
        my @urls = @{$pkg->{DOWNLOAD}};
        @url_md5{@urls} = @{$pkg->{MD5SUM}};
    }
    my $staging_dir = File::Temp->newdir(DIR => $CONFIG{TMPDIR}, TEMPLATE => 'sbozyp_XXXXXX');
    sbozyp_copy($pkg->{PKGDIR}, $staging_dir);
    for my $url (sort keys %url_md5) {
        my $src_filename = decode_url(basename($url));
        if ($keep_src && -r "$CONFIG{SRCDIR}/$src_filename") {
            # Sources stored from previous downloads have already been md5 checked
            sbozyp_print_stderr("$pkg->{PKGNAME}: using previously downloaded src: $src_filename\n");
            sbozyp_copy("$CONFIG{SRCDIR}/$src_filename", "$staging_dir/$src_filename");
        } else {
            my $md5 = $url_md5{$url};
            sbozyp_system('wget', '-e', 'background=off', '-O', "$staging_dir/$src_filename", $url);
            unless ($skip_md5) {
                my $got_md5 = do {
                    my $fh = sbozyp_open('<', "$staging_dir/$src_filename");
                    binmode($fh);
                    Digest::MD5->new->addfile($fh)->hexdigest;
                };
                if ($md5 ne $got_md5) {
                    sbozyp_die("md5sum mismatch for '$url': expected '$md5': got '$got_md5'");
                }
            }
            if ($keep_src) {
                sbozyp_mkdir($CONFIG{SRCDIR});
                sbozyp_copy("$staging_dir/$src_filename", "$CONFIG{SRCDIR}/$src_filename");
            }
        }	
    }
    return $staging_dir;
}

sub build_slackware_pkg {
    my ($pkg, $keep_src, $skip_md5) = @_;
    local $ENV{OUTPUT} = $CONFIG{TMPDIR}; # all SlackBuilds use the $OUTPUT env var to determine output pkg location
    sbozyp_mkdir($CONFIG{TMPDIR});
    my $staging_dir = pkg_prepare_for_build($pkg, $keep_src, $skip_md5);
    my $slackbuild = $pkg->{PRGNAM} . '.SlackBuild';
    my $cmd = with_cwd($staging_dir, sub {
        sbozyp_chmod(0755, "./$slackbuild");
        return sbozyp_open('-|', "./$slackbuild");
    });
    my $slackware_pkg; while (my $line = <$cmd>) {
        $slackware_pkg = $1 if $line =~ /^Slackware package (.+) created\.$/;
        print $line;
    }
    close $cmd;
    sbozyp_die("failed to build $pkg->{PKGNAME}") if $? != 0;
    sbozyp_die("successfully built $pkg->{PKGNAME} but couldn't determine the path of the created Slackware package") if !defined $slackware_pkg;
    return $slackware_pkg;
}

sub built_slackware_pkg {
    my ($pkg) = @_;
    my $output = $CONFIG{TMPDIR};
    return [ glob "$output/$pkg->{PRGNAM}*$pkg->{VERSION}*_SBo*" ]->[0];
}

sub install_slackware_pkg {
    my ($slackware_pkg) = @_;
    sbozyp_system('upgradepkg', '--reinstall', '--install-new', $slackware_pkg);
}

sub remove_slackware_pkg {
    my ($slackware_pkg) = @_;
    sbozyp_system('removepkg', $slackware_pkg);
}

            ####################################################
            #               REPOSITORY MANAGEMENT              #
            ####################################################

sub set_repo_name_or_die {
    my ($repo_name) = @_;
    my $repo_num = repo_name_repo_num($repo_name);
    if (defined $repo_num) {
        $CONFIG{REPO_NAME} = $repo_name;
    } else {
        sbozyp_die("no repo named '$repo_name'");
    }
}

sub repo_name_repo_num {
    my ($repo_name) = @_;
    my $repo_num;
    for my $k (grep /^REPO_.+_NAME/, sort keys %CONFIG) {
        my $v = $CONFIG{$k};
        if ($v eq $repo_name) {
            ($repo_num) = $k =~ /^REPO_(\d+)_NAME/;
        }
    }
    return $repo_num;
}

sub repo_num_git_branch {
    my ($repo_num) = @_;
    for my $k (sort keys %CONFIG) {
        return $CONFIG{$&} if $k =~ /^REPO_\Q$repo_num\E_GIT_BRANCH$/;
    }
}

bin/sbozyp  view on Meta::CPAN

            my $cmp = $v1 cmp $v2;
            return 0 if $cmp < 0;
            return 1 if $cmp > 0;
        }
    }
    return @v1 > @v2 ? 1 : 0;
}

sub sbozyp_mkdir {
    my @dirs = @_;
    for my $dir (@dirs) {
        unless (-d $dir) {
            make_path($dir, {error => \my $err});
            if ($err) {
                for my $diag (@$err) {
                    my (undef, $err_msg) = %$diag;
                    sbozyp_die("could not mkdir '$dir': $err_msg");
                }
            }
        }
    }
    return @dirs;
}

sub sbozyp_rmdir_rec {
    my ($dir) = @_;
    if (-d $dir) {
        remove_tree($dir, {error => \my $err});
        if ($err) {
            for my $diag (@$err) {
                my (undef, $err_msg) = %$diag;
                sbozyp_die("could not recursively delete directory '$dir': $err_msg");
            }
        }
    }
}

sub sbozyp_copy {
    my ($file, $dest) = @_;
    sbozyp_system('cp', '-a', -d $file ? "$file/." : $file, $dest);
}

sub sbozyp_readdir {
    my ($dir) = @_;
    opendir(my $dh, $dir) or sbozyp_die("could not opendir '$dir': $!");
    my @files = sort map { "$dir/$_" } grep { !/^\.\.?$/ } readdir($dh);
    return @files;
}

sub sbozyp_open {
    my ($mode, $path) = @_;
    open(my $fh, $mode, $path) or sbozyp_die("could not open file '$path': $!");
    return $fh;
}

sub sbozyp_unlink {
    my ($file) = @_;
    unlink $file or sbozyp_die("could not unlink file '$file': $!");
}

sub sbozyp_chmod {
    my ($mode, $file) = @_;
    chmod $mode, $file or sbozyp_die(sprintf("could not chmod 0%o '%s': %s", $mode, $file, $!));
}

sub sbozyp_chdir {
    my ($dir) = @_;
    chdir $dir or sbozyp_die("could not chdir '$dir': $!");
}

sub sbozyp_print_file {
    my ($file) = @_;
    my $fh = sbozyp_open('<', $file);
    print while <$fh>;
}

sub sbozyp_error_prefix {
    return 'sbozyp: error: ';
}

sub sbozyp_die {
    $! = 1;
    die sbozyp_error_prefix(), @_, "\n";
}

sub sbozyp_msg_prefix {
    return 'sbozyp: ';
}

sub sbozyp_print {
    print sbozyp_msg_prefix(), @_;
}

sub sbozyp_print_stderr {
    print STDERR sbozyp_msg_prefix(), @_;
}

1;

__END__

            ####################################################
            #                      MANUAL                      #
            ####################################################

=pod

=head1 NAME

sbozyp - A package manager for Slackware's SlackBuilds.org

=head1 DESCRIPTION

Sbozyp is a command-line package manager for the SlackBuilds.org package
repository. SlackBuilds.org is a collection of third-party SlackBuild scripts
used to build Slackware packages.

Sbozyp assumes its users have an understanding of SlackBuilds and the
SlackBuilds.org repository. While sbozyp provides conveniences to make it easier
to build, install, and remove packages, users should always understand every
package they consider installing by reading its README file.

Sbozyp does not handle optional dependencies or setting build-time options, so